diff --git a/.changeset/adapter-package-split.md b/.changeset/adapter-package-split.md new file mode 100644 index 000000000..13d871f4c --- /dev/null +++ b/.changeset/adapter-package-split.md @@ -0,0 +1,28 @@ +--- +'@cipherstash/stack': minor +'@cipherstash/stack-drizzle': minor +'@cipherstash/stack-supabase': minor +--- + +Split the Drizzle and Supabase integrations into their own packages. + +The adapters now ship as first-party packages that depend on `@cipherstash/stack`, +following the `@cipherstash/prisma-next` precedent: + +- **`@cipherstash/stack-drizzle`** — Drizzle ORM integration. EQL v2 on the package + root (`@cipherstash/stack-drizzle`: `encryptedType`, `extractEncryptionSchema`, + `createEncryptionOperators`) and EQL v3 on `@cipherstash/stack-drizzle/v3` + (`types` factories, `createEncryptionOperatorsV3`, `extractEncryptionSchemaV3`, …). +- **`@cipherstash/stack-supabase`** — Supabase integration: `encryptedSupabase` (v2) + and `encryptedSupabaseV3` (v3, connect-time introspection). + +**Breaking (`@cipherstash/stack`):** the `./drizzle`, `./supabase`, and +`./eql/v3/drizzle` subpath exports are removed. Migrate imports: + +- `@cipherstash/stack/drizzle` → `@cipherstash/stack-drizzle` +- `@cipherstash/stack/eql/v3/drizzle` → `@cipherstash/stack-drizzle/v3` +- `@cipherstash/stack/supabase` → `@cipherstash/stack-supabase` + +Add the relevant package to your dependencies alongside `@cipherstash/stack`. A new +`@cipherstash/stack/adapter-kit` subpath exposes the narrow core internals the +first-party adapters consume; it is the core↔adapter seam, not general-purpose API. diff --git a/.changeset/adapter-split-skills.md b/.changeset/adapter-split-skills.md new file mode 100644 index 000000000..772eeb21d --- /dev/null +++ b/.changeset/adapter-split-skills.md @@ -0,0 +1,11 @@ +--- +'stash': patch +--- + +Update the bundled `stash-drizzle`, `stash-supabase`, and `stash-encryption` agent +skills (and the stack README / Supabase reference doc) for the adapter package +split: the Drizzle and Supabase integrations import from `@cipherstash/stack-drizzle` +(+ `/v3`) and `@cipherstash/stack-supabase` respectively, installed alongside +`@cipherstash/stack`, rather than from `@cipherstash/stack/{drizzle,supabase,eql/v3/drizzle}` +subpaths. Skills ship inside the `stash` tarball, so the stale import paths would +otherwise become wrong guidance in a user's project. diff --git a/.changeset/cli-eql-v3-single-bundle.md b/.changeset/cli-eql-v3-single-bundle.md new file mode 100644 index 000000000..25db56023 --- /dev/null +++ b/.changeset/cli-eql-v3-single-bundle.md @@ -0,0 +1,16 @@ +--- +'stash': minor +--- + +`stash eql install --eql-version 3` now installs the eql-3.0.0 GA bundle, +vendored from the pinned `@cipherstash/eql` package (sha256-verified). + +Since eql-3.0.0 one artifact installs everywhere: the operator-class +statements self-skip when the role lacks superuser (managed Postgres, +Supabase) and the bundle disables the ORE-backed encrypted domains it cannot +support. The separate v3 Supabase bundle variant is gone — `--supabase` and +`--exclude-operator-family` no longer select a different v3 file (the role +GRANTs for `eql_v3` / `eql_v3_internal` still apply with `--supabase`). + +The bundled skills are also refreshed for the eql-3.0.0 naming convention +(`public.eql_v3_` column domains) and the EQL v3 typed-schema surface. diff --git a/.changeset/eql-v3-adapter-type-robustness.md b/.changeset/eql-v3-adapter-type-robustness.md new file mode 100644 index 000000000..f7cddd986 --- /dev/null +++ b/.changeset/eql-v3-adapter-type-robustness.md @@ -0,0 +1,38 @@ +--- +'@cipherstash/stack': minor +--- + +Restore the EQL v3 envelope and `Result` types the adapters were erasing. + +Both v3 adapters typed their operand-encryption paths as `unknown` and dropped +the `Result` wrapper, so the query-type encoding and the failure channel were +invisible to the type system: + +- `eql/v3/drizzle/operators.ts` typed the client's `encrypt`/`bulkEncrypt` as + returning `unknown`, collapsed the operation's `Result` to + `{ data?: unknown; failure?: { message } }`, and cast the bulk response to + `Array<{ data: unknown }>`. +- `supabase/query-builder-v3.ts` returned `Promise` from + `encryptCollectedTerms`, `bulkEncryptGroup` and `encryptGroupPerTerm`, and the + base `query-builder.ts` did the same. + +These now carry the SDK's real types — `Encrypted` (the storage envelope union, +which includes every v3 per-domain payload), `BulkEncryptedData`, and +`EncryptedQueryResult` — threaded through a properly-typed operation surface that +resolves `Result`. The Supabase divergence the erasure hid is +now explicit: the v2 path yields `encryptQuery` composite literals and the v3 +path yields `JSON.stringify`'d envelope strings, and both are `EncryptedQueryResult`. + +Bumped `minor`, not `patch`: `createEncryptionOperatorsV3` is a public export +(`@cipherstash/stack/eql/v3/drizzle`), and tightening its client contract from +`unknown` to a typed operation surface is a compile-time breaking change — a +downstream consumer passing a loosely-typed (`unknown`-returning) client double +will now fail `tsc`. That tightening has teeth: `operators.test-d.ts` pins it +with a negative type-test asserting an `unknown`-returning `{ encrypt }` double +is rejected (a positive "correctly-typed double is accepted" assertion cannot +catch a re-erasure, since a correct value is assignable to `unknown`). + +Behaviour is otherwise unchanged, with one addition: the Supabase v3 bulk path +now rejects a `null` envelope returned by `bulkEncrypt` (the restored +`Encrypted | null` type makes that arm reachable, and a `null` would otherwise +be `JSON.stringify`'d to the literal `"null"` and sent as a filter operand). diff --git a/.changeset/eql-v3-bigint-domains.md b/.changeset/eql-v3-bigint-domains.md new file mode 100644 index 000000000..240795836 --- /dev/null +++ b/.changeset/eql-v3-bigint-domains.md @@ -0,0 +1,11 @@ +--- +'@cipherstash/stack': minor +--- + +Add the EQL v3 bigint domain family to the public DSL: `types.Bigint`, +`types.BigintEq`, `types.BigintOrdOre`, and `types.BigintOrd`, backed by the +`public.bigint*` concrete domains. Plaintext is a JS `bigint`, round-tripped +losslessly across the protect-ffi 0.28 boundary (i64 bounds enforced at the +FFI — out-of-range values surface as encryption errors). Index emission follows +the numeric rule: `bigint_eq` → unique (hm); `bigint_ord`/`bigint_ord_ore` → +ore (equality answered via ob). diff --git a/.changeset/eql-v3-bundle-from-package.md b/.changeset/eql-v3-bundle-from-package.md new file mode 100644 index 000000000..951686176 --- /dev/null +++ b/.changeset/eql-v3-bundle-from-package.md @@ -0,0 +1,9 @@ +--- +'@cipherstash/stack': patch +--- + +Source the EQL v3 install bundle from `@cipherstash/eql@3.0.0-alpha.3` instead of a hand-vendored 43k-line SQL fixture committed to the test tree. The package publishes its SQL and its TypeScript wire types from the same `eql-bindings` commit, so the bundle is now pinned to a released EQL version rather than tracked by convention. + +Test-and-tooling only — `@cipherstash/eql` is a `devDependency` and no public API changes. + +The staleness check in the v3 install helper now compares `eql_v3.version()` against the pinned release instead of probing for a hand-picked sentinel domain. The previous sentinel (`public.timestamp`) exists in both the old and new bundles, so it would have reported a stale install as current and left the suite silently running the wrong SQL. diff --git a/.changeset/eql-v3-cli-install.md b/.changeset/eql-v3-cli-install.md new file mode 100644 index 000000000..68f88e443 --- /dev/null +++ b/.changeset/eql-v3-cli-install.md @@ -0,0 +1,13 @@ +--- +"stash": minor +--- + +Add an EQL v3 install path to `stash eql install` via a new `--eql-version <2|3>` +flag (default `2`). v3 installs the native concrete-domain schema (`public.*` +type domains, `eql_v3` operators, `eql_v3_internal` constructors) from bundles +vendored into `packages/cli/src/sql` by `scripts/build-eql-v3-sql.mjs` (full +bundle + a Supabase variant with the two superuser-only operator-class chunks +stripped). v3 currently supports the direct install path only — +`--drizzle`/`--migration`/`--migrations-dir`/`--latest` are rejected — and the +installer keys `isInstalled`/version checks and Supabase grants to the `eql_v3` +schema. diff --git a/.changeset/eql-v3-drizzle-encrypt-query.md b/.changeset/eql-v3-drizzle-encrypt-query.md new file mode 100644 index 000000000..a0874de90 --- /dev/null +++ b/.changeset/eql-v3-drizzle-encrypt-query.md @@ -0,0 +1,22 @@ +--- +'@cipherstash/stack-drizzle': minor +'@cipherstash/stack': minor +--- + +EQL v3 Drizzle: encrypt every query operand with `encryptQuery`, not `encrypt` (#622). + +The v3 Drizzle operators (`eq`/`ne`/`gt`/`gte`/`lt`/`lte`/`between`/`notBetween`/ +`inArray`/`notInArray`/`contains`) previously encrypted their operands with +`client.encrypt`, producing a full storage envelope (including the ciphertext `c`) +cast to `::jsonb`. A WHERE-clause operand should be a query *term*, not a value to +store. Every operator now uses `client.encryptQuery`, which yields a +ciphertext-free query term cast to the column's `eql_v3.query_` type — so +predicates carry no ciphertext and reach the bundle's `(domain, query_)` +operator overloads. This unifies the scalar/text operators with the JSON +containment path (already on `encryptQuery`) and removes the previously-optional +`encryptQuery` guard: it is now a required capability of the operand client. + +`@cipherstash/stack` gains a batch `encryptQuery(terms)` overload on +`TypedEncryptionClient` (the type `EncryptionV3` returns), mirroring the nominal +`EncryptionClient`. This is additive — it lets `inArray`/`notInArray` encrypt a +whole list of query terms in one crossing. diff --git a/.changeset/eql-v3-drizzle-fail-open-guards.md b/.changeset/eql-v3-drizzle-fail-open-guards.md new file mode 100644 index 000000000..990508580 --- /dev/null +++ b/.changeset/eql-v3-drizzle-fail-open-guards.md @@ -0,0 +1,38 @@ +--- +'@cipherstash/stack': minor +--- + +Close two fail-open paths in the EQL v3 Drizzle adapter. + +`ops.contains()` now throws `EncryptionOperatorError` for a search term that +tokenizes to nothing: the empty string, or a term shorter than the match index +tokenizer's `token_length` (3 by default). Such a term produces an empty bloom +filter, and `stored_bf @> '{}'` is true for every row — so a user searching +`"ad"` silently received the entire table. Measured live, the terms `"ad"`, +`"a"` and `"x"` each returned every seeded row, including one in which `"x"` +did not appear. + +The floor counts Unicode codepoints, matching the tokenizer. A UTF-16 length +check would wave through an astral-plane term — `"👍👍"` is 4 code units but +only 2 codepoints, yields no trigram, and matched every row. + +**Breaking for callers passing short terms:** `contains()` calls that previously +returned every row now throw. Terms of 3+ codepoints are unaffected. + +`v3FromDriver()` now throws the new `EqlV3CodecError` on a payload that is not +an EQL envelope, instead of surfacing a raw `SyntaxError` for malformed JSON and +passing a bare scalar through unchecked — `v3FromDriver('5')` previously returned +`5` typed as `Encrypted`, which then reached `decrypt` as garbage. The guard +accepts both scalar envelopes (ciphertext at `c`) and SteVec documents +(ciphertext at `sv[0].c`). A SteVec's `sv` must be a non-empty array: `sv[0]` is +the decryption root, so `sv: []` carries a ciphertext key but no ciphertext, and +is now rejected rather than passed to `decrypt`. `EqlV3CodecError` is exported +from `@cipherstash/stack/eql/v3/drizzle` so callers can catch it. + +Also removes an unreachable branch in `inArray`/`notInArray`, whose empty-list +guard already throws before it. + +Note: the v2 Drizzle adapter's `like`/`ilike` path builds the same bloom filters +and has the same short-term fail-open. It is **not** fixed here — v2 terms carry +SQL wildcards, so the floor must be measured against what its tokenizer actually +receives before the shared guard can be reused. Tracked separately. diff --git a/.changeset/eql-v3-drizzle.md b/.changeset/eql-v3-drizzle.md new file mode 100644 index 000000000..aa45af42a --- /dev/null +++ b/.changeset/eql-v3-drizzle.md @@ -0,0 +1,17 @@ +--- +"@cipherstash/stack": minor +--- + +Add EQL v3 Drizzle support at `@cipherstash/stack/eql/v3/drizzle`. A Drizzle-native +`types` namespace (same PascalCase names as `@cipherstash/stack/eql/v3`) declares +encrypted columns whose Postgres type is the semantic `public.`; the concrete +type drives the legal query operators. `createEncryptionOperatorsV3` provides +capability-checked `eq`/`ne`/`gt`/`gte`/`lt`/`lte`/`between`/`contains`/`inArray`/ +`asc`/`desc`/`and`/`or` that emit the latest two-argument `eql_v3` SQL functions with +full-envelope operands, and +`extractEncryptionSchemaV3` rebuilds the schema for `EncryptionV3`. The existing v2 +`@cipherstash/stack/drizzle` integration is unchanged. + +The v3 text-search helper is `contains`; obsolete `like`/`ilike` helpers are not +exposed because v3 free-text search is token containment rather than SQL wildcard +matching. diff --git a/.changeset/eql-v3-ffi-0-28-concrete-types.md b/.changeset/eql-v3-ffi-0-28-concrete-types.md new file mode 100644 index 000000000..8ee56528e --- /dev/null +++ b/.changeset/eql-v3-ffi-0-28-concrete-types.md @@ -0,0 +1,5 @@ +--- +'@cipherstash/stack': minor +--- + +Upgrade `@cipherstash/protect-ffi` to 0.28.0 and update EQL v3 concrete Postgres domain names to match the SQL fixture (`integer*`, `smallint*`, `bool`, `real*`, and `double*`). The public factories remain semantic (`Integer`, `Smallint`, `Boolean`, `Real`, `Double`) while their concrete domains change, so this is a minor release. diff --git a/.changeset/eql-v3-ga-rebaseline.md b/.changeset/eql-v3-ga-rebaseline.md new file mode 100644 index 000000000..f0b8fdbee --- /dev/null +++ b/.changeset/eql-v3-ga-rebaseline.md @@ -0,0 +1,23 @@ +--- +'@cipherstash/stack': minor +--- + +Re-baseline EQL v3 on the eql-3.0.0 GA release and protect-ffi 0.29. + +- **Breaking (v3 preview surface):** the EQL v3 column domains follow the + eql-3.0.0 naming convention — flat, prefixed names in `public` + (`public.eql_v3_text_search`, `public.eql_v3_integer_ord`, …) instead of the + alpha-era bare names. Databases installed from an alpha bundle must be + re-installed (`stash eql install --eql-version 3` replaces the schema). +- `encryptQuery` under `eqlVersion: 3` now returns EQL v3 query operands + (protect-ffi 0.29): term-only scalar operands for the `eql_v3.query_` + domains, the `eql_v3.query_jsonb` containment needle, and bare selector + hashes for JSON path queries — v3 scalar and selector queries no longer + throw `EQL_V3_QUERY_UNSUPPORTED` (the code is gone). +- v2 `searchableJson()` columns now pin the SteVec encoding to `standard` + explicitly. protect-ffi 0.29 flipped the library default to `compat` + (EQL v3's encoding); without the pin, v2 JSON containment queries would + silently match nothing and newly written rows would not be comparable with + existing ones. +- The EQL v3 test/install SQL is sourced from the pinned `@cipherstash/eql` + package (3.0.0) instead of a hand-vendored fixture. diff --git a/.changeset/eql-v3-json-skills.md b/.changeset/eql-v3-json-skills.md new file mode 100644 index 000000000..979c4e672 --- /dev/null +++ b/.changeset/eql-v3-json-skills.md @@ -0,0 +1,8 @@ +--- +'stash': patch +--- + +Document EQL v3 JSON columns in the bundled skills: `types.Json` in the +`stash-encryption` typed-schema catalog (capability suffix, family, and an +encrypted-JSONB query section), and `contains(col, subObject)` JSON containment +on the v3 Drizzle operators in `stash-drizzle`. diff --git a/.changeset/eql-v3-json.md b/.changeset/eql-v3-json.md new file mode 100644 index 000000000..6544cc04c --- /dev/null +++ b/.changeset/eql-v3-json.md @@ -0,0 +1,18 @@ +--- +'@cipherstash/stack': minor +--- + +Add EQL v3 JSON columns. `types.Json('col')` declares a `public.eql_v3_json` +column that encrypts a JSON document to an ste_vec `SteVecDocument` and +round-trips it losslessly through `encrypt`/`decrypt` and the model path. A new +`searchableJson` query capability emits the ste_vec index; the index uses +`mode: 'compat'`, which eql-3.0.0's `eql_v3_json` requires (it orders ste_vec +entries by the CLLW-OPE `op` term, so v2's `'standard'`/CLLW-`oc` terms are +rejected). + +The Drizzle integration's `contains(col, subObject)` now answers encrypted-JSONB +containment on a `types.Json` column, emitting the `@>` operator with a +`query_jsonb` needle (from `encryptQuery`). The ste_vec index indexes array +elements by identity but not position, so containment is a true subset test +(`{ roles: ['x'] }` matches any document whose `roles` array contains `x`, +regardless of index). diff --git a/.changeset/eql-v3-public-domains.md b/.changeset/eql-v3-public-domains.md new file mode 100644 index 000000000..65659d4ce --- /dev/null +++ b/.changeset/eql-v3-public-domains.md @@ -0,0 +1,5 @@ +--- +'@cipherstash/stack': patch +--- + +Re-vendor the EQL v3 SQL bundle and align the v3 DSL to it: encrypted type domains now live in the `public` schema (`public.text`, `public.integer`, …) rather than `eql_v3`, and the boolean domain is `public.boolean` (was `eql_v3.bool`). The `eql_v3` schema now holds only the operator-backing functions, and the index-term constructors (`hmac_256`, `ore_block_256`, `bloom_filter`) moved to `eql_v3_internal`. This keeps the SDK's emitted domain names byte-matched to the installed bundle so `CREATE TABLE`/cast resolution succeeds. diff --git a/.changeset/eql-v3-rename-contains-to-matches.md b/.changeset/eql-v3-rename-contains-to-matches.md new file mode 100644 index 000000000..2e576b464 --- /dev/null +++ b/.changeset/eql-v3-rename-contains-to-matches.md @@ -0,0 +1,30 @@ +--- +'@cipherstash/stack-drizzle': minor +'@cipherstash/stack-supabase': minor +--- + +Rename the EQL v3 encrypted free-text operator `contains()` → `matches()` (#617). + +Encrypted free-text search is fuzzy bloom-filter token matching — order- and +multiplicity-insensitive and one-sided (a `true` may be a false positive) — not +containment. The name `contains()` promised substring/containment semantics it +never had. It is renamed to `matches()` on the encrypted surface; `contains()` is +kept for genuine, exact containment: + +- **Drizzle** (`@cipherstash/stack-drizzle/v3`): `matches()` = bloom free-text on + `text_match`/`text_search` columns; `contains()` = exact encrypted-JSON `@>` on + `types.Json` (ste_vec) columns. +- **Supabase** (`@cipherstash/stack-supabase`): `.matches()` = encrypted free-text; + `.contains()` = native jsonb/array `@>` on plaintext columns (and throws on an + encrypted column, pointing to `matches()`). + +Also on the Supabase v3 surface, `like()`/`ilike()` on an encrypted column are no +longer rejected — they are delegated to `matches()` as a best-effort compatibility +shim. This is APPROXIMATE (fuzzy, case-insensitive, one-sided; anchoring and +wildcards are not honored): surrounding `%` are stripped, an internal `%` or any +`_` is rejected, and a one-time warning is emitted. A plaintext column keeps real +SQL LIKE. + +Breaking: encrypted `contains()` callers must migrate to `matches()`. The +encrypted operator has not shipped in a stable release (it lands via the EQL v3 +work), so there is no deprecation alias. diff --git a/.changeset/eql-v3-supabase-adapter.md b/.changeset/eql-v3-supabase-adapter.md new file mode 100644 index 000000000..f690a896a --- /dev/null +++ b/.changeset/eql-v3-supabase-adapter.md @@ -0,0 +1,67 @@ +--- +'@cipherstash/stack': minor +--- + +Add `encryptedSupabaseV3` — the EQL v3 dialect of the Supabase adapter. It is +now a connect-time-async factory: `await encryptedSupabaseV3(url, key)` (or +`(client)`) introspects the database over `DATABASE_URL`, detects EQL v3 columns +by their Postgres domain (`information_schema.columns.domain_name`), and derives +each column's encryption config from its domain — callers no longer pass a +schema to `from()`. `select('*')` is supported (expanded from the introspected +column list, and aliased back to each declared column's JS property name so a +property→DB rename round-trips). A column using an EQL v3 domain this SDK version does not model +(e.g. `public.json`, `*_ord_ope`) throws at construction rather than silently +passing through. Supplying `schemas` remains optional and adds compile-time +types plus startup verification of the declared tables against the database. +Requires a Postgres connection for introspection (`pg` is a new optional peer), +so it cannot run in a Worker or the browser. + +Every column name a query carries — filters, `match`, `not`, raw `filter`, +`or()`, `order()`, and the `onConflict` option — is now resolved from its JS +property name to its DB column name in a single pass before the query is built, +so a declared rename round-trips everywhere rather than only on the paths that +remembered to translate. + +`order()` on ANY encrypted v3 column is now rejected — at compile time when +`schemas` is supplied, and at runtime otherwise. The EQL v3 domains are +`DOMAIN … AS jsonb` and the bundle declares no btree operator class on them, so +`ORDER BY col` resolves through jsonb's default `jsonb_cmp` and sorts by the +envelope's byte structure: a stable, plausible-looking, meaningless row order, +with no error. Correct ordering is `ORDER BY eql_v3.ord_term(col)`, which +PostgREST's `order=` cannot express. Order by a plaintext column, expose +`eql_v3.ord_term()` as a generated column or view, or use the EQL v3 Drizzle +integration, which emits `ord_term` directly. Note `gte`/`lte` filters remain +correct: the comparison operators *are* declared on the ord domains, and only +sorting resolves through the missing operator class. + +`.or()` now understands PostgREST's `column.not..` negation. It was +previously parsed as `{ op: 'not', value: '.' }`, so on an encrypted +column `or('nickname.not.in.(ada,grace)')` encrypted the literal string +`in.(ada,grace)` as a single plaintext and produced a filter that silently +matched nothing. + +Free-text search on the v3 builder is `contains(column, value)`. `like`/`ilike` +are not exposed, because EQL v3 free-text search is token containment over a +bloom filter (`@>`, backed by `eql_v3.contains`) rather than SQL wildcard +matching — `%` is tokenized like any other character, so a `like` pattern is a +category error. This matches the v3 Drizzle integration, which omits them for +the same reason. On an encrypted column `like`/`ilike` now throw and name +`contains`; on a plaintext column they remain ordinary PostgREST filters. + +`contains` is narrowed at compile time to columns whose domain carries the +`freeTextSearch` capability (`public.text_match`, `public.text_search`), and +guarded at runtime for the untyped surface. A raw `filter(column, operator, …)` +on an encrypted v3 column now derives its query type from the operator instead +of always encrypting an equality term, so `filter('bio', 'cs', …)` on a +`public.text_match` column works rather than being rejected, and an unsupported +operator throws instead of silently encrypting the wrong term. + +Substring `contains` matches any needle whose trigrams are all present in the +stored value; needles shorter than the tokenizer's window (3 characters) bloom to +nothing and are rejected rather than silently matching every row. The v3 match +index now emits `include_original: false` — the flag is inert in protect-ffi (the +bloom is trigram-only either way), so this moves no ciphertext and only pins the +value a substring-search domain wants. + +v2 (`encryptedSupabase`) is unchanged: it keeps `like`/`ilike` (`eql_v2.like`, +`~~`) and its raw-`filter` query-type mapping, so no v2 ciphertext moves. diff --git a/.changeset/eql-v3-text-search.md b/.changeset/eql-v3-text-search.md new file mode 100644 index 000000000..1abbb1918 --- /dev/null +++ b/.changeset/eql-v3-text-search.md @@ -0,0 +1,18 @@ +--- +"@cipherstash/stack": minor +--- + +Add the EQL v3 `text_search` authoring DSL on a new `@cipherstash/stack/eql/v3` +subpath (`types.TextSearch`, v3 `encryptedTable` / `buildEncryptConfig`). The v3 +builders emit the existing `EncryptConfig` shape, so encryption, payloads, and +query paths are unchanged at runtime. + +Also widens the public client types (`EncryptionClientConfig.schemas`, +`EncryptOptions`, `SearchTerm`/`EncryptQueryOptions`) to a structural contract so +both v2 and v3 builders are accepted by `Encryption` / `encrypt` / `decrypt` / +`encryptQuery`. This is a backward-compatible widening — existing v2 usage is +unaffected. The structural contracts themselves (`BuildableColumn`, +`BuildableQueryColumn`, `BuildableV3QueryableColumn`, `BuildableTable`, +`BuildableTableColumns`) and the `encryptModel` return-type mapper +(`EncryptedFromBuildableTable`) are exported from `@cipherstash/stack/types` so +consumers can name them. diff --git a/.changeset/eql-v3-typed-client.md b/.changeset/eql-v3-typed-client.md new file mode 100644 index 000000000..884b2ad8d --- /dev/null +++ b/.changeset/eql-v3-typed-client.md @@ -0,0 +1,29 @@ +--- +"@cipherstash/stack": minor +--- + +Add a strongly-typed EQL v3 client surface on a new `@cipherstash/stack/v3` +subpath (`EncryptionV3`, `typedClient`, `TypedEncryptionClient`). It re-exports +the v3 `types` namespace and table API (from `@cipherstash/stack/eql/v3`), so a +single import provides everything needed to author and use a v3 schema. + +Every method derives its types from the concrete `table` / `column` builder +arguments: + +- `encrypt` / `encryptQuery` pin the plaintext to the column's domain type + (`text → string`, `timestamp → Date`, …). +- `encryptQuery` constrains `queryType` to the column's capabilities and rejects + storage-only columns at compile time. +- `encryptModel` / `bulkEncryptModels` validate schema-column fields against their + inferred plaintext type (passthrough fields are untouched) and return a precise + encrypted model. +- `decryptModel` / `bulkDecryptModels` return the precise plaintext model, + reconstructing `Date` 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` +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 000000000..780e562de --- /dev/null +++ b/.changeset/eql-v3-typed-schema.md @@ -0,0 +1,7 @@ +--- +'@cipherstash/stack': minor +--- + +Add EQL v3 schema builders for supported generated SQL domains under `@cipherstash/stack/eql/v3`, exposed as the `types` namespace (one member per supported EQL v3 domain, e.g. `types.TextEq` / `types.IntegerOrd` / `types.Timestamp`), including explicit query capability metadata (`getQueryCapabilities()` / `isQueryable()`) and v3 table support in model encryption helpers (`encryptModel` / `bulkEncryptModels`). + +Also widen the accepted plaintext input type for `encrypt` / `encryptQuery` to include `Date` (via the new `Plaintext` type), so v3 `date` / `timestamp` domains can be encrypted and queried with their natural JavaScript values. diff --git a/.changeset/eql-v3-wasm-inline.md b/.changeset/eql-v3-wasm-inline.md new file mode 100644 index 000000000..6c30ba376 --- /dev/null +++ b/.changeset/eql-v3-wasm-inline.md @@ -0,0 +1,30 @@ +--- +'@cipherstash/stack': minor +--- + +`@cipherstash/stack/wasm-inline` is now EQL v3 (#614). + +The WASM entry (Deno / Bun / Cloudflare Workers / Supabase Edge) previously +created a client pinned to the FFI's EQL v2 wire format, so a v3 schema +(concrete `eql_v3_*` domains) failed every encrypt on the edge. It now targets +EQL v3 exclusively: + +- The factory constructs the WASM client with `eqlVersion: 3`, so v3 schemas + encrypt/decrypt correctly on the edge. +- The entry re-exports the **v3** authoring surface (`types`, `encryptedTable`, + the column classes, `buildEncryptConfig`, and the inference helpers) — the + same API as `@cipherstash/stack/eql/v3` — so an Edge Function authors and runs + v3 from one import: + + ```ts + import { Encryption, encryptedTable, types } from "@cipherstash/stack/wasm-inline" + + const patients = encryptedTable("patients", { email: types.TextSearch("email") }) + const client = await Encryption({ schemas: [patients], config }) + ``` + +The v2 schema builders (`encryptedColumn` / `encryptedField` / the v2 +`encryptedTable`) are no longer exported from this entry, and passing a v2 table +throws a clear error. The WASM path was never announced or documented for v2 and +had no known users; EQL v2 remains fully supported on the native +`@cipherstash/stack` entry. diff --git a/.changeset/rename-db-install-to-eql-install.md b/.changeset/rename-db-install-to-eql-install.md new file mode 100644 index 000000000..3c1a2b1aa --- /dev/null +++ b/.changeset/rename-db-install-to-eql-install.md @@ -0,0 +1,11 @@ +--- +"stash": minor +"@cipherstash/wizard": minor +--- + +Rename `stash db install` to `stash eql install`. The command scaffolds +`stash.config.ts` and installs the EQL extensions, so it now lives under a +dedicated `eql` command group. `stash db install` keeps working as a +deprecated alias that prints a warning pointing at the new name. All help +text, hints, generated migration headers, and wizard steps now reference +`stash eql install`. diff --git a/.changeset/schema-stevec-standard-pin.md b/.changeset/schema-stevec-standard-pin.md new file mode 100644 index 000000000..d96bf3ca6 --- /dev/null +++ b/.changeset/schema-stevec-standard-pin.md @@ -0,0 +1,8 @@ +--- +'@cipherstash/schema': patch +--- + +`searchableJson()` now pins the SteVec encoding mode to `standard` explicitly. +protect-ffi 0.29 flipped the library default to `compat` (the EQL v3 +encoding); pinning keeps the v2 wire format byte-stable so existing encrypted +JSON columns stay queryable and comparable. diff --git a/.changeset/stack-adapter-kit.md b/.changeset/stack-adapter-kit.md new file mode 100644 index 000000000..43bc5ccd0 --- /dev/null +++ b/.changeset/stack-adapter-kit.md @@ -0,0 +1,12 @@ +--- +'@cipherstash/stack': minor +--- + +Add the `@cipherstash/stack/adapter-kit` subpath — a narrow support surface for +the first-party adapter packages (`@cipherstash/stack-supabase`, +`@cipherstash/stack-drizzle`) being split out of this package (#627). It +re-exports exactly the core internals the adapters consume (the logger, +`AuditConfig`, the v3 column model + `DATE_LIKE_CASTS`, the domain registry, the +match-index guard, and the model→composite helpers) so those imports resolve +across the package boundary without leaking six internal module paths. This is the +core↔adapter seam, not general-purpose public API. diff --git a/.changeset/stash-cli-eql-v3-default.md b/.changeset/stash-cli-eql-v3-default.md new file mode 100644 index 000000000..b19eecc57 --- /dev/null +++ b/.changeset/stash-cli-eql-v3-default.md @@ -0,0 +1,10 @@ +--- +"stash": minor +--- + +Default EQL to v3 and stop the CLI recommending `stash db push` (#585). + +- **EQL v3 is now the default.** `stash eql install` and `stash eql upgrade` target v3 (the native `eql_v3.*` domain schema) without `--eql-version 3`. The v2-only paths — `--drizzle`, `--migration`, `--migrations-dir`, and `--latest` — now require an explicit `--eql-version 2` and error with clear guidance otherwise (v3 installs via the direct path only). `stash init` pins v2 automatically when it drives the Drizzle migration flow. **Note:** for a Supabase project, `stash init` now runs a v3 direct install rather than offering the v2 migration-file flow; run `stash eql install --supabase --migration --eql-version 2` if you want a checked-in migration file. +- **`stash db push` is no longer recommended in CLI output.** `db push` writes the `public.eql_v2_configuration` table, which is a v2 + CipherStash Proxy artifact — EQL v3 has no configuration table (config lives in each column's `eql_v3.*` type) and nothing in the v3 stack reads it. The push recommendations are removed from `eql status`, the help banner, and the init/plan/cutover guidance. `db push` (and `db activate`) remain available for EQL v2 + Proxy users; they're now labelled as such. +- **`eql status` is v3-aware.** On a v3-only database it reports that encrypt config lives in the column types instead of hitting a "table not found" dead-end that told users to run `db push` (which neither creates that table nor applies to v3). +- **`stash db push` guards a v3-only database** with a clear "not needed under EQL v3" message instead of a raw `relation "public.eql_v2_configuration" does not exist` error. diff --git a/.changeset/stash-drizzle-skill-encrypt-query.md b/.changeset/stash-drizzle-skill-encrypt-query.md new file mode 100644 index 000000000..9e5ea14c7 --- /dev/null +++ b/.changeset/stash-drizzle-skill-encrypt-query.md @@ -0,0 +1,9 @@ +--- +'stash': patch +--- + +Correct the `stash-drizzle` skill: `inArray` / `notInArray` now encrypt the whole +list in a single `encryptQuery` batch crossing (the `bulkEncrypt`/concurrency +fallback was removed when v3 query operands moved to `encryptQuery` — #622). The +skill ships inside the `stash` tarball, so this keeps the bundled guidance in step +with the adapter's behaviour. diff --git a/.changeset/stash-skills-contains-to-matches.md b/.changeset/stash-skills-contains-to-matches.md new file mode 100644 index 000000000..88c709c4b --- /dev/null +++ b/.changeset/stash-skills-contains-to-matches.md @@ -0,0 +1,10 @@ +--- +'stash': patch +--- + +Update the `stash-drizzle` and `stash-supabase` skills for the EQL v3 +`contains()` → `matches()` rename (#617): the encrypted free-text operator is now +`matches()` (fuzzy bloom token matching), `contains()` is reserved for exact +containment, and Supabase `like()`/`ilike()` on encrypted columns are documented +as an approximate compatibility shim delegating to `matches()`. Skills ship inside +the `stash` tarball, so they must track the adapter surface. diff --git a/.changeset/stash-supabase-contains-substrings.md b/.changeset/stash-supabase-contains-substrings.md new file mode 100644 index 000000000..ca0df909a --- /dev/null +++ b/.changeset/stash-supabase-contains-substrings.md @@ -0,0 +1,14 @@ +--- +"stash": patch +--- + +Correct the bundled `stash-supabase` agent skill: EQL v3 `contains()` matches +substrings. The skill previously carried the reverse — that `contains()` matched +only exact values because the query's bloom filter appended the whole search term +as an extra token. That was never true: `include_original` is inert in +protect-ffi (the match bloom is trigram-only either way), so any substring of at +least the tokenizer's `token_length` (3 characters) matches, and shorter terms are +rejected rather than silently matching every row. The skills directory ships +inside the `stash` tarball and is copied into the user's `.claude/skills/` / +`.codex/skills/` (or inlined into `AGENTS.md`) at handoff time, so the stale +sentence was shipping wrong guidance into customer repos. diff --git a/.changeset/supabase-encryption-error.md b/.changeset/supabase-encryption-error.md new file mode 100644 index 000000000..d83143e0a --- /dev/null +++ b/.changeset/supabase-encryption-error.md @@ -0,0 +1,11 @@ +--- +'@cipherstash/stack-supabase': patch +--- + +Populate `EncryptedSupabaseError.encryptionError` on encryption failures (#626). +The query builder's catch block previously hardcoded `encryptionError: undefined`, +so the typed field was always empty and callers had to detect encryption failures +indirectly (via `status`/`statusText` or `.throwOnError()`). It now threads the +underlying `EncryptionError` through — for both the v2 and v3 dialects — when the +failure originates in an encrypt/decrypt step, and leaves it unset for plain +PostgREST/API errors. diff --git a/.changeset/supabase-in-list-operands.md b/.changeset/supabase-in-list-operands.md new file mode 100644 index 000000000..360e23370 --- /dev/null +++ b/.changeset/supabase-in-list-operands.md @@ -0,0 +1,92 @@ +--- +'@cipherstash/stack': minor +--- + +Fix encrypted `in`-list operands in the Supabase adapter, and widen the `is` / +`contains` type surfaces. + +**`in()` on an encrypted column produced a request PostgREST rejects.** Every +encrypted operand is a serialized envelope, dense with `"` and `,`. postgrest-js +wraps a comma-bearing element as `"…"` but never escapes the quotes already +inside it, so `.in('email', […])` emitted + +``` +in.("{"v":1,"c":"…"}",…) + ^ PostgREST ends the value here → PGRST100 +``` + +Encrypted lists are now emitted through `filter(col, 'in', …)` with each element +quoted and escaped, matching what the `.or()` path already did. This affects +**v2 as well as v3** — v2's `("a@b.com")` composite literal is itself +quote-bearing and was equally broken. + +**`not(col, 'in', […])` encrypted the whole list as a single ciphertext**, so +the filter silently matched nothing, and emitted an unparenthesized +`not.in.a,b`. Each element is now encrypted separately and the operand is +rendered as `not.in.(…)`. Passing a PostgREST list literal (`'(a,b)'`) for an +encrypted column now throws instead of silently matching nothing — pass an +array. + +**`filter(col, 'in', […])` encrypted the whole list as a single ciphertext.** +The raw `.filter()` path reached `in` with none of the element-splitting the +`in()`, `not(…, 'in', …)` and `.or()` paths perform, so the entire list operand +was encrypted as one equality term. The two wire formats then failed +differently, which is why this went unnoticed: **v2**'s `("json")` composite +literal is already parenthesized, so PostgREST parsed it as a one-element list +and answered `200 []` — a filter that silently matched nothing. **v3**'s bare +`{…}` envelope is not, so PostgREST rejected the request outright with +`PGRST100 (failed to parse filter)`. + +Each element is now encrypted separately and the operand rendered as a quoted +PostgREST list literal. As on the `not` path, passing a list literal +(`'(a,b)'`) for an encrypted column now throws instead — pass an array. + +Plaintext columns are unaffected, including the pre-existing quirk that +postgrest-js renders `.filter(col, 'in', [array])` as an unparenthesized +`in.a,b` that PostgREST rejects; pass a list literal there, or use `.in()`. + +**`is(col, null)` is now allowed on every column**, including storage-only +encrypted ones (`types.Boolean`, `types.Integer`, …). `is` is never encrypted +and a NULL plaintext is stored as a SQL NULL, so `IS NULL` is not merely legal +there but the only predicate those columns support. `is(col, true)` remains a +compile error on encrypted columns. + +**`contains()` accepts native operands on plaintext array and jsonb columns.** A +plaintext jsonb/array column falls through to PostgREST's native containment, so +`contains('tags', ['vip'])` and `contains('meta', { plan: 'pro' })` now +typecheck. A plaintext SCALAR column does not: `@>` is undefined on `text`, so +the operand type follows the column's own shape and a scalar rejects every +containment operand. Encrypted match columns still take a `string` token. +Relatedly, `.or([{ op: 'contains' }])` now emits PostgREST's `cs` operator for +plaintext columns too — previously only encrypted conditions were translated, so +a plaintext containment reached the wire as `.contains.` and failed to parse. + +**Direct `contains()` / `not(col, 'contains', …)` now serialize their operand.** +postgrest-js builds an array operand as `cs.{a,b}` with no element quoting, so +`contains('tags', ['with,comma'])` reached Postgres as two elements; and its +`not()` stringifies the operand outright, emitting `not.contains.with,comma` +(no braces, and the wrong operator token) or `[object Object]` for a jsonb +operand. Both paths now build the containment literal the `.or()` path already +built, and emit the `cs` token. + +**`.or()` no longer drops a condition after an unbalanced brace or paren.** A +scalar operand containing `{` left the parser's depth counter stranded above +zero, so no later comma separated a condition and everything behind it was +swallowed into that operand. With a plaintext column first, the group was then +forwarded verbatim — running the swallowed condition against a ciphertext column +with a plaintext operand. Braces are now quoted on emit (they are structural to +PostgREST inside `or=(…)`), and the parser falls back to quote-only splitting +when its depth tracking does not balance. + +**`is(col, true)` is now rejected on every encrypted column, not just the +storage-only ones.** The boolean form was gated on the filterable keys, which +exclude storage-only columns but keep queryable encrypted ones — so +`is(emailTextSearchColumn, true)` compiled and emitted `IS TRUE` against a jsonb +ciphertext. + +**In-list operands encrypt in one crossing per column.** The element-wise `in` / +`not.in` encoding above spent one ZeroKMS round-trip per element; terms are now +grouped by column and each group takes a single `bulkEncrypt` call, matching the +Drizzle v3 path. Falls back to per-term encryption for clients without +`bulkEncrypt`, and rejects a bulk response whose length does not match the list +rather than silently truncating the predicate. diff --git a/.changeset/supabase-is-null-operands.md b/.changeset/supabase-is-null-operands.md new file mode 100644 index 000000000..46478aa24 --- /dev/null +++ b/.changeset/supabase-is-null-operands.md @@ -0,0 +1,27 @@ +--- +'@cipherstash/stack': patch +--- + +Fix the Supabase adapter encrypting `is` and `null` filter operands. + +`is` is a SQL predicate — PostgREST accepts only `null`/`true`/`false` after it +— and a `null` operand is SQL NULL, never a value to search for. Only the direct +`.is()` filter skipped encryption; `not()`, `or()`, `match()`, raw `filter()`, +and the `in()` element list all encrypted whatever they were handed. So +`or('age.is.null')` emitted `age.is."("null")"` and `eq('email', null)` emitted +`email=("null")` — operands PostgREST rejects. A null plaintext is stored as a +NULL column rather than ciphertext, so it is found with an unencrypted +`IS NULL`; encrypting the operand could never match. + +A single `isEncryptableTerm(operator, value)` predicate now guards every term +collector. Affects both `encryptedSupabase` (v2) and `encryptedSupabaseV3`. On +v3 this additionally removes a spurious `does not support equality queries` +error, which `is` raised because it maps to the `equality` query type and so hit +the column-capability guard — `or('active.is.null')` on a storage-only column +threw rather than querying. + +Relatedly, an `or()` string is now rebuilt whenever a condition *references* an +encrypted column, not only when one of its values was encrypted. An `is` on an +encrypted column encrypts nothing, and the old condition sent it down the +verbatim path, forwarding the caller's JS property name to a database that only +knows the column's DB name. diff --git a/.changeset/supabase-or-string-parser.md b/.changeset/supabase-or-string-parser.md new file mode 100644 index 000000000..25db66e67 --- /dev/null +++ b/.changeset/supabase-or-string-parser.md @@ -0,0 +1,19 @@ +--- +'@cipherstash/stack': patch +--- + +Fix the Supabase adapter's `.or()` string parser mis-splitting conditions, and pin `contains()` on a mixed union column key to the encrypted operand. + +An `.or()` string is only rebuilt from its parse when it references an encrypted column — otherwise the caller's string is forwarded verbatim — so each of these corrupts precisely the mixed encrypted/plaintext case. + +**Quotes were tracked only at brace depth 0.** A `}` inside a quoted array element or jsonb string value closed the literal early, and the next `"` re-opened quoting, so the following top-level comma never split: `.or('tags.cs.{"a}b"},email.eq.secret')` parsed as a single condition and silently absorbed `email.eq.secret` into the operand. Quotes are now opaque at every depth. + +**A stray `}` or `)` drove the depth counter negative**, after which no comma split again. `}` and `)` are not PostgREST reserved characters, so `a}b` is a valid unquoted operand and `.or('nickname.eq.a}b,id.eq.1')` dropped `id.eq.1`. Depth now floors at zero. + +**`in`-list elements were split on every comma, ignoring quotes.** `.or('email.in.("a,b",c)')` parsed as three elements with the quotes still embedded; on an encrypted column each fragment was encrypted as its own term, so the intended element never matched. Elements are now split on top-level commas and unquoted, the inverse of what the rebuild emits. + +**A parenthesized operand was read as a list for every operator.** Only `in` and the range operators (`ov`, `sl`, `sr`, `nxr`, `nxl`, `adj`) take a paren-delimited operand; elsewhere `(` is an ordinary character. `email.eq.(foo)` parsed as `['foo']` and encrypted a JS array rather than the string, matching nothing. + +**A string operand spelling `null`, `true` or `false` is now quoted.** PostgREST reads a bare `null` as SQL NULL, so `.or([{ column: 'name', op: 'eq', value: 'null' }])` emitted `name.eq.null` and compared against NULL instead of the three-character string. + +**`contains(col, …)` where `col` is a union spanning an encrypted and a plaintext column** accepted an array or object operand. The union is now only as permissive as its strictest member: any declared encrypted column in the union pins the operand to `string`. A literal column argument was never affected. diff --git a/.changeset/supabase-v3-order-by-ope-term.md b/.changeset/supabase-v3-order-by-ope-term.md new file mode 100644 index 000000000..33d450239 --- /dev/null +++ b/.changeset/supabase-v3-order-by-ope-term.md @@ -0,0 +1,47 @@ +--- +'@cipherstash/stack': minor +--- + +**`order()` now works on EQL v3 encrypted ordering columns in the Supabase +adapter.** It was rejected outright on every encrypted column. + +A bare `ORDER BY col` on an EQL v3 domain really is wrong — the bundle declares +no btree operator class on any domain, so the sort falls through to jsonb's +default `jsonb_cmp` and compares the envelope's keys in storage order, starting +at the random ciphertext `c`. Measured over ten rows it returns +`r00,r04,r08,r01,…` where the plaintext order is `r00..r09`. No error, a stable +and plausible-looking meaningless order. + +But the correct sort key is reachable without a function call. `eql_v3.ord_term` +returns the domain's `op` term, and OPE is order-preserving, so ordering by the +term reproduces the plaintext order. PostgREST cannot emit +`ORDER BY eql_v3.ord_term(col)`, but it can emit a jsonb path. The builder now +emits `order=col->op` for an encrypted ordering column, verified against a live +PostgREST for `integer_ord` and `text_search` in both directions. + +The guard is now on the ordering FLAVOUR, not on encryption: + +- **`ope` present → supported.** Every plain `*_ord` domain, plus `text_ord` and + `text_search`. +- **`ore` present → rejected.** The `ob` term is an array of ORE blocks whose + comparison needs the superuser-only operator class, which no jsonb path can + reach. (Such a column cannot hold data on managed Postgres anyway: its domain + CHECK raises `ore_domain_unavailable`.) ORE columns are now excluded from + `order()` at COMPILE time too, not only at runtime — `.order(oreColumn)` is a + type error, matching the rejection. +- **neither → rejected.** Storage-only, equality-only and match-only columns + carry no ordering term. + +The path is `col->op` (jsonb), not `col->>op` (text). Neither avoids the +database collation — Postgres compares jsonb strings with `varstr_cmp` under the +default collation, exactly as it does text. What makes the ordering +collation-independent is the term's encoding: lowercase hex, fixed-width for +numeric and date domains, and per-character (16 hex chars each) for text, so +lexicographic order reproduces plaintext order including the prefix case +(`ada` < `adam`). `ope-term.integration.test.ts` pins that shape. + +`V3OrderableKeys` widens to admit OPE-backed ordering columns (`*_ord`, +`text_ord`, `text_search`) while still excluding ORE (`*_ord_ore`) columns, so +`order()` typechecks exactly where it works. `is(col, true)` is unaffected — it +stays plaintext-only, and now has its own `V3PlaintextKeys` rather than +borrowing the orderable set. diff --git a/.github/actions/integration-setup/action.yml b/.github/actions/integration-setup/action.yml new file mode 100644 index 000000000..171eddfc6 --- /dev/null +++ b/.github/actions/integration-setup/action.yml @@ -0,0 +1,47 @@ +name: Integration test setup +description: >- + Checkout, pnpm, Node, dependencies, and a built `stash` CLI — the common + preamble for every integration workflow. The CLI build is required, not + incidental: the integration harness installs EQL v3 by shelling out to + `stash eql install --eql-version 3`, so an installer regression fails the job + rather than hiding behind a test-only SQL apply. + +inputs: + node-version: + description: Node major to run the suites on. + required: false + # The newest major `tests.yml` exercises, and what the repo develops on. + # `engines` is `>=22`; the unit job still covers 22 in its matrix. + default: '24' + +runs: + using: composite + 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: ${{ inputs.node-version }} + 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 + shell: bash + run: npm install -g node-gyp + + - name: Install dependencies + shell: bash + run: pnpm install --frozen-lockfile + + - name: Build the stash CLI (used to install EQL v3) + shell: bash + run: pnpm exec turbo run build --filter stash diff --git a/.github/actions/require-cs-secrets/action.yml b/.github/actions/require-cs-secrets/action.yml new file mode 100644 index 000000000..95fee4238 --- /dev/null +++ b/.github/actions/require-cs-secrets/action.yml @@ -0,0 +1,43 @@ +name: Require CipherStash secrets +description: >- + Fail the job when any CS_* credential is missing. The live test suites gate + themselves on these vars (vitest `describe.skip`, Deno `test.ignore`), so a + rotated / cleared / fork-PR-absent secret would make them silently skip and + let CI go green with ZERO live coverage. This turns that silent skip into a + loud failure. Requires the repo to be checked out first (local action path). + +inputs: + workspace-crn: + description: vars.CS_WORKSPACE_CRN + required: true + client-id: + description: vars.CS_CLIENT_ID + required: true + client-key: + description: secrets.CS_CLIENT_KEY + required: true + client-access-key: + description: secrets.CS_CLIENT_ACCESS_KEY + required: true + +runs: + using: composite + steps: + - name: Assert CS_* secrets are present + shell: bash + env: + CS_WORKSPACE_CRN: ${{ inputs.workspace-crn }} + CS_CLIENT_ID: ${{ inputs.client-id }} + CS_CLIENT_KEY: ${{ inputs.client-key }} + CS_CLIENT_ACCESS_KEY: ${{ inputs.client-access-key }} + run: | + missing=0 + for v in CS_WORKSPACE_CRN CS_CLIENT_ID CS_CLIENT_KEY CS_CLIENT_ACCESS_KEY; do + if [ -z "${!v}" ]; then + echo "::error::Required secret $v is not set on this runner — live test suites would silently skip." + missing=1 + fi + done + if [ "$missing" -ne 0 ]; then + exit 1 + fi diff --git a/.github/workflows/fta-v3.yml b/.github/workflows/fta-v3.yml index b5cea5a6a..95659a4f9 100644 --- a/.github/workflows/fta-v3.yml +++ b/.github/workflows/fta-v3.yml @@ -1,7 +1,8 @@ -name: "FTA Complexity (EQL v3)" +name: "FTA Complexity" -# 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 +# Blocking complexity gate for the EQL v3 core (stack) and the split adapter +# packages (stack-drizzle, stack-supabase). Runs the Fast TypeScript Analyzer +# (fta-cli) against each package's source 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. @@ -12,6 +13,12 @@ on: - 'main' paths: - 'packages/stack/src/eql/v3/**' + - 'packages/stack-drizzle/**' + - 'packages/stack-supabase/**' + # Shared match-index defaults live outside src/eql/v3 but shape every + # emitted v3 match block (load-bearing `k`/`m` ciphertext params), so edits + # here must trigger the v3 gate too. + - 'packages/stack/src/schema/match-defaults.ts' - 'packages/stack/package.json' - '.github/workflows/fta-v3.yml' pull_request: @@ -19,6 +26,9 @@ on: - "**" paths: - 'packages/stack/src/eql/v3/**' + - 'packages/stack-drizzle/**' + - 'packages/stack-supabase/**' + - 'packages/stack/src/schema/match-defaults.ts' - 'packages/stack/package.json' - '.github/workflows/fta-v3.yml' @@ -56,5 +66,17 @@ jobs: # Non-zero exit (score above the cap) fails the check — this is the # blocking gate. No `continue-on-error`. - - name: Analyze v3 complexity + # One step per package so a failure names the offending package. Each caps + # at its current worst file (a ratchet, not an aspiration): stack src/eql/v3 + # at 69, and the split adapter packages at their monolith maxima — drizzle + # 89 (operators.ts), supabase 91 (query-builder.ts). Lower a cap whenever a + # file is refactored below the next threshold; the v2 query-builder/operators + # monoliths are the debt to whittle down toward stack's 69. + - name: Analyze stack (eql/v3) complexity run: pnpm --filter @cipherstash/stack run analyze:complexity + + - name: Analyze stack-drizzle complexity + run: pnpm --filter @cipherstash/stack-drizzle run analyze:complexity + + - name: Analyze stack-supabase complexity + run: pnpm --filter @cipherstash/stack-supabase run analyze:complexity diff --git a/.github/workflows/integration-drizzle.yml b/.github/workflows/integration-drizzle.yml new file mode 100644 index 000000000..0b2a9b835 --- /dev/null +++ b/.github/workflows/integration-drizzle.yml @@ -0,0 +1,175 @@ +name: Integration — Drizzle (EQL v3) + +# Real ZeroKMS ciphertext against a real Postgres, on BOTH database variants. +# +# The Drizzle adapter talks straight to the database, so it does not need +# PostgREST — but it does need to work on managed Postgres, where the `postgres` +# role is not a superuser, the EQL install takes its self-skipping path, and the +# ORE domains cannot hold data. The Supabase compose file brings up PostgREST +# too; this job simply ignores it, and leaves `PGRST_URL` unset so a Supabase +# suite scoped here would throw rather than silently skip. +# +# Separate from `tests.yml` on purpose: these suites need CipherStash credentials +# and a database, and they THROW rather than skip when unconfigured. Keeping them +# out of the unit job is what lets `pnpm test` stay runnable with neither. + +on: + push: + branches: [main] + paths: + - 'packages/stack/src/eql/v3/**' + - 'packages/stack-drizzle/**' + # Source layers the adapter's encoding/round-trip rests on: a break here + # (not just under src/eql/v3) can produce wrong rows, so trigger the live + # suite that would catch it. + - 'packages/stack/src/encryption/**' + - 'packages/stack/src/schema/**' + - 'packages/schema/**' + - 'packages/stack/integration/**' + - 'packages/test-kit/**' + - 'packages/cli/src/installer/**' + - 'local/docker-compose.postgres.yml' + - 'local/docker-compose.supabase.yml' + - 'local/supabase-init.sql' + - '.github/workflows/integration-drizzle.yml' + - '.github/actions/integration-setup/**' + pull_request: + branches: ['**'] + # Repeated verbatim: GitHub Actions does not support YAML anchors/aliases. + paths: + - 'packages/stack/src/eql/v3/**' + - 'packages/stack-drizzle/**' + # Source layers the adapter's encoding/round-trip rests on: a break here + # (not just under src/eql/v3) can produce wrong rows, so trigger the live + # suite that would catch it. + - 'packages/stack/src/encryption/**' + - 'packages/stack/src/schema/**' + - 'packages/schema/**' + - 'packages/stack/integration/**' + - 'packages/test-kit/**' + - 'packages/cli/src/installer/**' + - 'local/docker-compose.postgres.yml' + - 'local/docker-compose.supabase.yml' + - 'local/supabase-init.sql' + - '.github/workflows/integration-drizzle.yml' + - '.github/actions/integration-setup/**' + +jobs: + integration: + name: Drizzle v3 integration (db=${{ matrix.db }}) + runs-on: blacksmith-4vcpu-ubuntu-2404 + # Serialize every job that brings up the SAME docker-compose stack, so no two + # bind the same fixed host ports on a shared runner at once (the "address + # already in use" flake). Keyed by the compose variant, NOT the ref (two PRs + # contend for a host port just as much as two pushes to one PR), so it + # serializes across refs. The `supabase` leg uses the SAME supabase compose + # (55430 / 55433) as the Supabase workflow and shares its key + # (`integration-live-db-supabase`), so the two workflows queue rather than + # collide; the `postgres` leg (55432) has its own key and still runs in + # parallel with them. + concurrency: + group: integration-live-db-${{ matrix.db }} + cancel-in-progress: false + # Fork PRs have no secrets. Skip cleanly rather than fail on something the + # contributor cannot fix — `tests.yml` still gives them a green signal. + if: ${{ github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository }} + + strategy: + fail-fast: false + # Drizzle talks straight to Postgres, so it runs against BOTH databases. + # The Supabase variant is not a formality: its `postgres` role is not a + # superuser, so the EQL install takes its self-skipping path and the ORE + # domains become unusable. A suite that passes on a superuser database can + # still fail there. + matrix: + include: + - db: postgres + database-url: postgres://cipherstash:password@localhost:55432/cipherstash + pgrest-url: '' + - db: supabase + database-url: postgres://postgres:password@localhost:55433/postgres + # The supabase compose file starts PostgREST anyway. Drizzle does not + # use it, but supplying the URL lets the harness assert the `anon` + # path on the database it is actually running against. + pgrest-url: http://localhost:55430 + + env: + CS_WORKSPACE_CRN: ${{ vars.CS_WORKSPACE_CRN }} + CS_CLIENT_ID: ${{ vars.CS_CLIENT_ID }} + CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }} + CS_CLIENT_ACCESS_KEY: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # The identity suites federate a freshly-minted Clerk M2M JWT into a CTS + # token. Only they read these; the other suites ignore them. If one is + # unset the relevant suite fails loudly (throw, never skip) rather than + # taking the whole job down, so they are NOT in the require-cs-secrets + # preflight. `_B` is a SECOND machine (a distinct `sub`) in the same Clerk + # instance, used only by the cross-identity test. + CLERK_MACHINE_TOKEN: ${{ secrets.CLERK_MACHINE_TOKEN }} + CLERK_MACHINE_TOKEN_B: ${{ secrets.CLERK_MACHINE_TOKEN_B }} + # Job-level env, not a `.env` file: `dotenv/config` does not override an + # already-set `process.env`, so these win and no secret is written to disk. + DATABASE_URL: ${{ matrix.database-url }} + PGRST_URL: ${{ matrix.pgrest-url }} + # EXPLICIT, never inferred. The variant decides whether EQL is installed + # with `--supabase` (and therefore whether the role grants are applied). + # Inferring it from `PGRST_URL` reported `postgres` for this job's Supabase + # cell and silently skipped the grants. + CS_IT_DB_VARIANT: ${{ matrix.db }} + # Scoped by directory, never by named file, so a renamed suite cannot + # silently drop from CI. `integration/shared/` holds the adapter-agnostic + # suites (harness, bloom, ope-term, the crypto/SQL matrices); + # `integration/identity/` holds the Clerk-federated lock-context suites + # (they need CLERK_MACHINE_TOKEN + a workspace with the Clerk issuer + # registered); the Supabase adapter suites are not run here — they have + # their own job. + # The Drizzle adapter suites (incl. the Clerk-federated lock-context one) + # now live in @cipherstash/stack-drizzle (run below via its own + # test:integration). This glob scopes what still lives in @cipherstash/stack: + # the adapter-agnostic `shared/` core suites and the model-path + # `identity/matrix-identity` suite. + CS_IT_SUITE: >- + integration/shared/**/*.integration.test.ts, + integration/identity/**/*.integration.test.ts + + steps: + - uses: actions/checkout@v6 + - uses: ./.github/actions/integration-setup + + # Fast pre-flight: fail in seconds if a secret was rotated or cleared, + # before the docker pull. The in-test `requireIntegrationEnv` is the + # correctness guarantee; this is the cheap one. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ vars.CS_WORKSPACE_CRN }} + client-id: ${{ vars.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + + # Belt-and-braces for the concurrency guard: a run that was hard-killed + # (runner crash / forced cancel) can skip its `down` and leak a container + # holding the host port onto a REUSED runner. Tear any prior stack down + # before starting a fresh one. `|| true` so a clean runner (nothing to + # remove) is not an error. + - name: Clear any leaked containers from a prior run + run: docker compose -f local/docker-compose.${{ matrix.db }}.yml down -v --remove-orphans || true + + - name: Start ${{ matrix.db }} + run: docker compose -f local/docker-compose.${{ matrix.db }}.yml up -d --wait + + # `globalSetup` installs EQL v3 by shelling out to the real + # `stash eql install --eql-version 3`, so an installer regression fails + # here rather than hiding behind a test-only SQL apply. + - name: Drizzle v3 integration suites + run: pnpm --filter @cipherstash/stack-drizzle run test:integration + + # A second vitest invocation (stack's shared/ + identity suites live in a + # different package now). Its globalSetup calls the same EQL v3 install, but + # `isInstalled` short-circuits against the DB the first invocation already + # provisioned — a fast no-op check, not a second schema apply. + - name: Shared core + identity integration suites + run: pnpm --filter @cipherstash/stack run test:integration + + - name: Stop ${{ matrix.db }} + if: always() + run: docker compose -f local/docker-compose.${{ matrix.db }}.yml down -v diff --git a/.github/workflows/integration-supabase.yml b/.github/workflows/integration-supabase.yml new file mode 100644 index 000000000..64252ff59 --- /dev/null +++ b/.github/workflows/integration-supabase.yml @@ -0,0 +1,147 @@ +name: Integration — Supabase (EQL v3) + +# Real ZeroKMS ciphertext, a real PostgREST, and `supabase/postgres` — the only +# job that proves the Supabase v3 adapter's queries return the right rows. The +# unit suites drive a mock that records strings; they cannot. +# +# Separate from `tests.yml` on purpose: these suites need CipherStash credentials +# and a database, and they THROW rather than skip when unconfigured. Keeping them +# out of the unit job is what lets `pnpm test` stay runnable with neither. + +on: + push: + branches: [main] + paths: + - 'packages/stack-supabase/**' + - 'packages/stack/src/eql/v3/**' + # Source layers the adapter's encoding/round-trip rests on: a break here + # (not just under src/supabase) can produce wrong wire output or rows, so + # trigger the live suite that would catch it. + - 'packages/stack/src/encryption/**' + - 'packages/stack/src/schema/**' + - 'packages/schema/**' + - 'packages/stack/integration/**' + - 'packages/test-kit/**' + - 'packages/cli/src/installer/**' + - 'local/docker-compose.supabase.yml' + - 'local/supabase-init.sql' + - '.github/workflows/integration-supabase.yml' + - '.github/actions/integration-setup/**' + pull_request: + branches: ['**'] + paths: + - 'packages/stack-supabase/**' + - 'packages/stack/src/eql/v3/**' + # Source layers the adapter's encoding/round-trip rests on: a break here + # (not just under src/supabase) can produce wrong wire output or rows, so + # trigger the live suite that would catch it. + - 'packages/stack/src/encryption/**' + - 'packages/stack/src/schema/**' + - 'packages/schema/**' + - 'packages/stack/integration/**' + - 'packages/test-kit/**' + - 'packages/cli/src/installer/**' + - 'local/docker-compose.supabase.yml' + - 'local/supabase-init.sql' + - '.github/workflows/integration-supabase.yml' + - '.github/actions/integration-setup/**' + +jobs: + integration: + name: Supabase v3 integration (db=${{ matrix.db }}) + runs-on: blacksmith-4vcpu-ubuntu-2404 + # Serialize every job that brings up the SAME docker-compose stack, so no two + # bind the same fixed host ports (55430 / 55433) on a shared runner at once — + # the "address already in use" flake. The group is keyed by the compose + # variant, NOT the ref: two different PRs contend for the same host port just + # as much as two pushes to one PR, so it must serialize across refs. It is the + # SAME key the Drizzle workflow's matching leg uses (`integration-live-db-`), + # so those two workflows also queue against each other rather than colliding. + # `cancel-in-progress: false` queues (a live-DB job that shares one ZeroKMS + # workspace should finish, not be interrupted mid-run). + concurrency: + group: integration-live-db-${{ matrix.db }} + cancel-in-progress: false + # Fork PRs have no secrets. Skip cleanly rather than fail loudly on something + # the contributor cannot fix — `tests.yml` still gives them a green signal. + if: ${{ github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository }} + + strategy: + # A one-element matrix, not a cross-product: the Supabase adapter only ever + # runs against the Supabase variant. Kept as a matrix so adding a second + # database is a one-line change. + matrix: + db: [supabase] + + env: + CS_WORKSPACE_CRN: ${{ vars.CS_WORKSPACE_CRN }} + CS_CLIENT_ID: ${{ vars.CS_CLIENT_ID }} + CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }} + CS_CLIENT_ACCESS_KEY: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Job-level env, not a `.env` file: `dotenv/config` does not override an + # already-set `process.env`, so these win and no secret is written to disk. + # + # `postgres` here is deliberately NOT a superuser on this image — that is + # what makes the EQL install, the grants, and the ORE opclass skip behave + # as they do on a real Supabase project. + DATABASE_URL: postgres://postgres:password@localhost:55433/postgres + PGRST_URL: http://localhost:55430 + # EXPLICIT, never inferred from `PGRST_URL` — see `dbVariant()`. + CS_IT_DB_VARIANT: ${{ matrix.db }} + # Scoped by directory, never by named file, so a renamed suite cannot + # silently drop from CI. `integration/shared/` holds the adapter-agnostic + # suites (harness, bloom, the ope-term tripwire for THIS job's `col->op` + # ordering path, and the crypto/SQL matrices); the Drizzle suites talk to + # plain Postgres and get their own job. + # + # `integration/identity/` runs on the Drizzle job (it needs Postgres + + # Drizzle, not PostgREST), so it is intentionally not listed here. + # The Supabase adapter suites now live in @cipherstash/stack-supabase (run + # below via its own test:integration). This glob scopes the adapter-agnostic + # `shared/` core suites that still live in @cipherstash/stack and run against + # this job's Postgres too. + CS_IT_SUITE: >- + integration/shared/**/*.integration.test.ts + + steps: + - uses: actions/checkout@v6 + - uses: ./.github/actions/integration-setup + + # Fast pre-flight: fail in seconds if a secret was rotated or cleared, + # before paying for the ~2 GB supabase/postgres pull. The in-test + # `requireIntegrationEnv` is the correctness guarantee; this is the cheap one. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ vars.CS_WORKSPACE_CRN }} + client-id: ${{ vars.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + + # Belt-and-braces for the concurrency guard: a run that was hard-killed + # (runner crash / forced cancel) can skip its `down` and leak a container + # holding the host port onto a REUSED runner. Tear any prior stack down + # before starting a fresh one. `|| true` so a clean runner (nothing to + # remove) is not an error. + - name: Clear any leaked containers from a prior run + run: docker compose -f local/docker-compose.${{ matrix.db }}.yml down -v --remove-orphans || true + + - name: Start ${{ matrix.db }} + run: docker compose -f local/docker-compose.${{ matrix.db }}.yml up -d --wait + + # `globalSetup` installs EQL v3 by shelling out to the real + # `stash eql install --eql-version 3 --supabase --direct`, so an installer + # regression fails here rather than hiding behind a test-only SQL apply. + - name: Supabase v3 integration suites + run: pnpm --filter @cipherstash/stack-supabase run test:integration + + # A second vitest invocation (stack's shared/ suites live in a different + # package now). Its globalSetup calls the same EQL v3 install, but + # `isInstalled` short-circuits against the DB the first invocation already + # provisioned — so this is a fast no-op check, not a second schema apply. + - name: Shared core integration suites (against Supabase Postgres) + run: pnpm --filter @cipherstash/stack run test:integration + + - name: Stop ${{ matrix.db }} + if: always() + run: docker compose -f local/docker-compose.${{ matrix.db }}.yml down -v diff --git a/.github/workflows/prisma-example-readme-e2e.yml b/.github/workflows/prisma-example-readme-e2e.yml index 96fe6b193..24c26b95b 100644 --- a/.github/workflows/prisma-example-readme-e2e.yml +++ b/.github/workflows/prisma-example-readme-e2e.yml @@ -36,8 +36,8 @@ jobs: if: ${{ github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository }} env: - CS_WORKSPACE_CRN: ${{ secrets.CS_WORKSPACE_CRN }} - CS_CLIENT_ID: ${{ secrets.CS_CLIENT_ID }} + CS_WORKSPACE_CRN: ${{ vars.CS_WORKSPACE_CRN }} + CS_CLIENT_ID: ${{ vars.CS_CLIENT_ID }} CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }} CS_CLIENT_ACCESS_KEY: ${{ secrets.CS_CLIENT_ACCESS_KEY }} @@ -65,6 +65,16 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # A missing / rotated / fork-PR-absent secret makes the walkthrough skip + # its live steps silently, hiding regressions behind a green job. Fail loud. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ vars.CS_WORKSPACE_CRN }} + client-id: ${{ vars.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Build via turbo so `^build` on `@cipherstash/prisma-next` and # its `@cipherstash/stack` peer is honoured. The test's # `pnpm install` subprocess inside `examples/prisma/` is a no-op diff --git a/.github/workflows/prisma-next-e2e.yml b/.github/workflows/prisma-next-e2e.yml index 11c3ee26e..a813824d6 100644 --- a/.github/workflows/prisma-next-e2e.yml +++ b/.github/workflows/prisma-next-e2e.yml @@ -38,8 +38,8 @@ jobs: if: ${{ github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository }} env: - CS_WORKSPACE_CRN: ${{ secrets.CS_WORKSPACE_CRN }} - CS_CLIENT_ID: ${{ secrets.CS_CLIENT_ID }} + CS_WORKSPACE_CRN: ${{ vars.CS_WORKSPACE_CRN }} + CS_CLIENT_ID: ${{ vars.CS_CLIENT_ID }} CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }} CS_CLIENT_ACCESS_KEY: ${{ secrets.CS_CLIENT_ACCESS_KEY }} @@ -67,6 +67,17 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # The global-setup hook hard-errors without CS_WORKSPACE_CRN, but a + # missing sibling secret could still degrade coverage silently — assert + # all four up front so a rotated / fork-PR-absent secret fails loudly. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ vars.CS_WORKSPACE_CRN }} + client-id: ${{ vars.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Write the CS_* credentials and the harness DATABASE_URL into the # example app's .env so the runtime + the `prisma-next migration # apply` invocation in global-setup both pick them up. The harness @@ -78,8 +89,8 @@ jobs: run: | touch ./examples/prisma/.env echo "DATABASE_URL=postgres://cipherstash:cipherstash@localhost:54329/cipherstash_e2e" >> ./examples/prisma/.env - echo "CS_WORKSPACE_CRN=${{ secrets.CS_WORKSPACE_CRN }}" >> ./examples/prisma/.env - echo "CS_CLIENT_ID=${{ secrets.CS_CLIENT_ID }}" >> ./examples/prisma/.env + echo "CS_WORKSPACE_CRN=${{ vars.CS_WORKSPACE_CRN }}" >> ./examples/prisma/.env + echo "CS_CLIENT_ID=${{ vars.CS_CLIENT_ID }}" >> ./examples/prisma/.env echo "CS_CLIENT_KEY=${{ secrets.CS_CLIENT_KEY }}" >> ./examples/prisma/.env echo "CS_CLIENT_ACCESS_KEY=${{ secrets.CS_CLIENT_ACCESS_KEY }}" >> ./examples/prisma/.env diff --git a/.github/workflows/tests-bench.yml b/.github/workflows/tests-bench.yml index eb793707b..829b0bd94 100644 --- a/.github/workflows/tests-bench.yml +++ b/.github/workflows/tests-bench.yml @@ -46,11 +46,13 @@ jobs: run: pnpm recursive install --frozen-lockfile # `@cipherstash/stack` ships dist/-based `exports`; bench imports - # from it (and `@cipherstash/stack/drizzle`) so the package needs - # to be built before vitest can resolve it. Going through turbo - # also picks up `^build` deps if any are added later. - - name: Build @cipherstash/stack - run: pnpm exec turbo run build --filter @cipherstash/stack + # from `@cipherstash/stack` and `@cipherstash/stack-drizzle` (the Drizzle + # adapter split out into its own package), so both must be built before + # vitest can resolve them — the drizzle bench/test files import + # `@cipherstash/stack-drizzle`. Going through turbo also picks up `^build` + # deps (stack-drizzle depends on stack). + - name: Build stack + adapter packages + run: pnpm exec turbo run build --filter @cipherstash/stack --filter @cipherstash/stack-drizzle # Starts the pinned postgres-eql container (PostgreSQL 17 + EQL # pre-installed) via local/docker-compose.yml; waits for healthcheck. diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 3b3a80d21..0a8c6143b 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -9,6 +9,43 @@ on: - "**" jobs: + # Biome format + lint. Its own job (no DB, no credentials, node-agnostic) so it + # surfaces as a distinct check and runs once rather than per Node matrix leg. + # Gates on ERRORS only — warnings are allowed, so the `no-type-erasing-assertions` + # plugin (at `warn`) surfaces new `as any`/`never`/`unknown` without blocking. + # Tightening to fail on warnings is tracked in #625. + lint: + name: Lint (Biome) + 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 22 is the supply-chain hardening baseline every pnpm-using job + # must pin (enforced by e2e/tests/supply-chain.e2e.test.ts). Lint is + # runtime-agnostic, so a single pinned version is fine. + 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 it. + - name: Install node-gyp + run: npm install -g node-gyp + + - name: Install dependencies + run: pnpm install --frozen-lockfile + + - name: Biome check (format + lint) + run: pnpm run code:check + run-tests: name: Run Tests (Node ${{ matrix.node-version }}) runs-on: blacksmith-4vcpu-ubuntu-2404 @@ -59,28 +96,46 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # Fail loudly if any live-test credential is missing, so the v3 live + # matrix (and every other `describeLive` suite) can't silently skip. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ vars.CS_WORKSPACE_CRN }} + client-id: ${{ vars.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + - name: Type tests (stack) run: pnpm --filter @cipherstash/stack run test:types + # The v3 domain catalog lives in the test kit, and its + # `satisfies Record` is what forces a new SDK + # domain to be covered. That check only fires under `tsc`, so without this + # step a domain added to stack would slip through untested. + - name: Type tests (test-kit — enforces v3 domain coverage) + run: pnpm --filter @cipherstash/test-kit run test:types + - name: Lint — no hardcoded package-manager runners run: pnpm run lint:runners - name: Test — lint script self-tests run: pnpm run test:scripts - # The EQL v3 bundles in packages/cli/src/sql are vendored (derived from - # the stack fixture monolith by gen:eql-v3-sql). Regenerate and fail on - # any diff so the fixture and the shipped bundles cannot drift silently. - - name: Check — vendored EQL v3 SQL bundles are in sync + # The EQL v3 bundle in packages/cli/src/sql is vendored from the pinned + # @cipherstash/eql package (sha256-verified by gen:eql-v3-sql). + # Regenerate and fail on any diff so the pin and the shipped bundle + # cannot drift silently. + - name: Check — vendored EQL v3 SQL bundle is in sync run: | pnpm --filter stash run gen:eql-v3-sql - git diff --exit-code -- packages/cli/src/sql/cipherstash-encrypt-v3.sql packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql + git diff --exit-code -- packages/cli/src/sql/cipherstash-encrypt-v3.sql - name: Create .env file in ./packages/protect/ run: | touch ./packages/protect/.env - echo "CS_WORKSPACE_CRN=${{ secrets.CS_WORKSPACE_CRN }}" >> ./packages/protect/.env - echo "CS_CLIENT_ID=${{ secrets.CS_CLIENT_ID }}" >> ./packages/protect/.env + echo "CS_WORKSPACE_CRN=${{ vars.CS_WORKSPACE_CRN }}" >> ./packages/protect/.env + echo "CS_CLIENT_ID=${{ vars.CS_CLIENT_ID }}" >> ./packages/protect/.env echo "CS_CLIENT_KEY=${{ secrets.CS_CLIENT_KEY }}" >> ./packages/protect/.env echo "CS_CLIENT_ACCESS_KEY=${{ secrets.CS_CLIENT_ACCESS_KEY }}" >> ./packages/protect/.env echo "DATABASE_URL=postgres://cipherstash:password@localhost:5432/cipherstash" >> ./packages/protect/.env @@ -88,8 +143,8 @@ jobs: - name: Create .env file in ./packages/stack/ run: | touch ./packages/stack/.env - echo "CS_WORKSPACE_CRN=${{ secrets.CS_WORKSPACE_CRN }}" >> ./packages/stack/.env - echo "CS_CLIENT_ID=${{ secrets.CS_CLIENT_ID }}" >> ./packages/stack/.env + echo "CS_WORKSPACE_CRN=${{ vars.CS_WORKSPACE_CRN }}" >> ./packages/stack/.env + echo "CS_CLIENT_ID=${{ vars.CS_CLIENT_ID }}" >> ./packages/stack/.env echo "CS_CLIENT_KEY=${{ secrets.CS_CLIENT_KEY }}" >> ./packages/stack/.env echo "CS_CLIENT_ACCESS_KEY=${{ secrets.CS_CLIENT_ACCESS_KEY }}" >> ./packages/stack/.env echo "DATABASE_URL=postgres://cipherstash:password@localhost:5432/cipherstash" >> ./packages/stack/.env @@ -97,16 +152,16 @@ jobs: - name: Create .env file in ./packages/protect-dynamodb/ run: | touch ./packages/protect-dynamodb/.env - echo "CS_WORKSPACE_CRN=${{ secrets.CS_WORKSPACE_CRN }}" >> ./packages/protect-dynamodb/.env - echo "CS_CLIENT_ID=${{ secrets.CS_CLIENT_ID }}" >> ./packages/protect-dynamodb/.env + echo "CS_WORKSPACE_CRN=${{ vars.CS_WORKSPACE_CRN }}" >> ./packages/protect-dynamodb/.env + echo "CS_CLIENT_ID=${{ vars.CS_CLIENT_ID }}" >> ./packages/protect-dynamodb/.env echo "CS_CLIENT_KEY=${{ secrets.CS_CLIENT_KEY }}" >> ./packages/protect-dynamodb/.env echo "CS_CLIENT_ACCESS_KEY=${{ secrets.CS_CLIENT_ACCESS_KEY }}" >> ./packages/protect-dynamodb/.env - name: Create .env file in ./packages/drizzle/ run: | touch ./packages/drizzle/.env - echo "CS_WORKSPACE_CRN=${{ secrets.CS_WORKSPACE_CRN }}" >> ./packages/drizzle/.env - echo "CS_CLIENT_ID=${{ secrets.CS_CLIENT_ID }}" >> ./packages/drizzle/.env + echo "CS_WORKSPACE_CRN=${{ vars.CS_WORKSPACE_CRN }}" >> ./packages/drizzle/.env + echo "CS_CLIENT_ID=${{ vars.CS_CLIENT_ID }}" >> ./packages/drizzle/.env echo "CS_CLIENT_KEY=${{ secrets.CS_CLIENT_KEY }}" >> ./packages/drizzle/.env echo "CS_CLIENT_ACCESS_KEY=${{ secrets.CS_CLIENT_ACCESS_KEY }}" >> ./packages/drizzle/.env echo "DATABASE_URL=postgres://cipherstash:password@localhost:5432/cipherstash" >> ./packages/drizzle/.env @@ -129,8 +184,8 @@ jobs: # are set. We expose them at the job level so the wizard subprocess # picks them up via `process.env`. env: - CS_WORKSPACE_CRN: ${{ secrets.CS_WORKSPACE_CRN }} - CS_CLIENT_ID: ${{ secrets.CS_CLIENT_ID }} + CS_WORKSPACE_CRN: ${{ vars.CS_WORKSPACE_CRN }} + CS_CLIENT_ID: ${{ vars.CS_CLIENT_ID }} CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }} CS_CLIENT_ACCESS_KEY: ${{ secrets.CS_CLIENT_ACCESS_KEY }} CS_ZEROKMS_HOST: https://ap-southeast-2.aws.zerokms.cipherstashmanaged.net @@ -160,6 +215,16 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # Auth-dependent `e2e/` suites skip themselves without these vars — a + # silent skip would hide regressions behind a green job. Fail loudly. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ vars.CS_WORKSPACE_CRN }} + client-id: ${{ vars.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Run the standalone `e2e/` workspace via turbo so the `^build` # dep on the `test:e2e` task builds cli + wizard first. CLI's own # E2E (`packages/cli/tests/e2e/**`) is covered by the `run-tests` @@ -183,8 +248,8 @@ jobs: # identity and region — the stack /wasm-inline config requires it and # derives the AccessKeyStrategy region from it. env: - CS_WORKSPACE_CRN: ${{ secrets.CS_WORKSPACE_CRN }} - CS_CLIENT_ID: ${{ secrets.CS_CLIENT_ID }} + CS_WORKSPACE_CRN: ${{ vars.CS_WORKSPACE_CRN }} + CS_CLIENT_ID: ${{ vars.CS_CLIENT_ID }} CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }} CS_CLIENT_ACCESS_KEY: ${{ secrets.CS_CLIENT_ACCESS_KEY }} @@ -227,19 +292,17 @@ jobs: - name: Build stack run: pnpm exec turbo run build --filter @cipherstash/stack - # roundtrip.test.ts skips itself (Deno.test.ignore) when any of - # the four CS_* env vars is missing — that's the right behaviour - # for local runs, but in CI a silent skip would mean a rotated / - # cleared secret hides a real WASM regression behind a green job. - # Fail loudly instead. - - name: Assert CS_* secrets are present - run: | - for v in CS_WORKSPACE_CRN CS_CLIENT_ID CS_CLIENT_KEY CS_CLIENT_ACCESS_KEY; do - if [ -z "${!v}" ]; then - echo "::error::Required secret $v is not set on this runner — the WASM smoke test would silently skip." - exit 1 - fi - done + # roundtrip.test.ts skips itself (Deno.test.ignore) when any of the four + # CS_* env vars is missing — fine locally, but in CI a silent skip would + # let a rotated / cleared secret hide a real WASM regression behind a + # green job. Fail loudly instead. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ vars.CS_WORKSPACE_CRN }} + client-id: ${{ vars.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} - name: Run Deno WASM smoke test working-directory: e2e/wasm @@ -291,8 +354,8 @@ jobs: - name: Create .env file in ./packages/protect/ run: | touch ./packages/protect/.env - echo "CS_WORKSPACE_CRN=${{ secrets.CS_WORKSPACE_CRN }}" >> ./packages/protect/.env - echo "CS_CLIENT_ID=${{ secrets.CS_CLIENT_ID }}" >> ./packages/protect/.env + echo "CS_WORKSPACE_CRN=${{ vars.CS_WORKSPACE_CRN }}" >> ./packages/protect/.env + echo "CS_CLIENT_ID=${{ vars.CS_CLIENT_ID }}" >> ./packages/protect/.env echo "CS_CLIENT_KEY=${{ secrets.CS_CLIENT_KEY }}" >> ./packages/protect/.env echo "CS_CLIENT_ACCESS_KEY=${{ secrets.CS_CLIENT_ACCESS_KEY }}" >> ./packages/protect/.env echo "DATABASE_URL=postgres://cipherstash:password@localhost:5432/cipherstash" >> ./packages/protect/.env @@ -300,8 +363,8 @@ jobs: - name: Create .env file in ./packages/stack/ run: | touch ./packages/stack/.env - echo "CS_WORKSPACE_CRN=${{ secrets.CS_WORKSPACE_CRN }}" >> ./packages/stack/.env - echo "CS_CLIENT_ID=${{ secrets.CS_CLIENT_ID }}" >> ./packages/stack/.env + echo "CS_WORKSPACE_CRN=${{ vars.CS_WORKSPACE_CRN }}" >> ./packages/stack/.env + echo "CS_CLIENT_ID=${{ vars.CS_CLIENT_ID }}" >> ./packages/stack/.env echo "CS_CLIENT_KEY=${{ secrets.CS_CLIENT_KEY }}" >> ./packages/stack/.env echo "CS_CLIENT_ACCESS_KEY=${{ secrets.CS_CLIENT_ACCESS_KEY }}" >> ./packages/stack/.env echo "DATABASE_URL=postgres://cipherstash:password@localhost:5432/cipherstash" >> ./packages/stack/.env @@ -309,16 +372,16 @@ jobs: - name: Create .env file in ./packages/protect-dynamodb/ run: | touch ./packages/protect-dynamodb/.env - echo "CS_WORKSPACE_CRN=${{ secrets.CS_WORKSPACE_CRN }}" >> ./packages/protect-dynamodb/.env - echo "CS_CLIENT_ID=${{ secrets.CS_CLIENT_ID }}" >> ./packages/protect-dynamodb/.env + echo "CS_WORKSPACE_CRN=${{ vars.CS_WORKSPACE_CRN }}" >> ./packages/protect-dynamodb/.env + echo "CS_CLIENT_ID=${{ vars.CS_CLIENT_ID }}" >> ./packages/protect-dynamodb/.env echo "CS_CLIENT_KEY=${{ secrets.CS_CLIENT_KEY }}" >> ./packages/protect-dynamodb/.env echo "CS_CLIENT_ACCESS_KEY=${{ secrets.CS_CLIENT_ACCESS_KEY }}" >> ./packages/protect-dynamodb/.env - name: Create .env file in ./packages/drizzle/ run: | touch ./packages/drizzle/.env - echo "CS_WORKSPACE_CRN=${{ secrets.CS_WORKSPACE_CRN }}" >> ./packages/drizzle/.env - echo "CS_CLIENT_ID=${{ secrets.CS_CLIENT_ID }}" >> ./packages/drizzle/.env + echo "CS_WORKSPACE_CRN=${{ vars.CS_WORKSPACE_CRN }}" >> ./packages/drizzle/.env + echo "CS_CLIENT_ID=${{ vars.CS_CLIENT_ID }}" >> ./packages/drizzle/.env echo "CS_CLIENT_KEY=${{ secrets.CS_CLIENT_KEY }}" >> ./packages/drizzle/.env echo "CS_CLIENT_ACCESS_KEY=${{ secrets.CS_CLIENT_ACCESS_KEY }}" >> ./packages/drizzle/.env echo "DATABASE_URL=postgres://cipherstash:password@localhost:5432/cipherstash" >> ./packages/drizzle/.env diff --git a/AGENTS.md b/AGENTS.md index d763293cf..0b0b4a023 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -72,7 +72,7 @@ If these variables are missing, tests that require live encryption will fail or ## Repository Layout - `packages/stack`: Main package (`@cipherstash/stack`) containing the encryption client and all integrations - - Subpath exports: `@cipherstash/stack`, `@cipherstash/stack/client`, `@cipherstash/stack/identity`, `@cipherstash/stack/schema`, `@cipherstash/stack/types`, `@cipherstash/stack/drizzle`, `@cipherstash/stack/dynamodb`, `@cipherstash/stack/supabase`, `@cipherstash/stack/encryption`, `@cipherstash/stack/errors`, `@cipherstash/stack/wasm-inline` + - Subpath exports: `@cipherstash/stack`, `@cipherstash/stack/client`, `@cipherstash/stack/identity`, `@cipherstash/stack/schema`, `@cipherstash/stack/eql/v3`, `@cipherstash/stack/v3`, `@cipherstash/stack/types`, `@cipherstash/stack/dynamodb`, `@cipherstash/stack/encryption`, `@cipherstash/stack/errors`, `@cipherstash/stack/adapter-kit`, `@cipherstash/stack/wasm-inline` (the Drizzle and Supabase integrations moved to their own packages — see below) - `packages/protect`: Core encryption library (internal, re-exported via `@cipherstash/stack`) - `src/index.ts`: Public API (`Encryption`, exports) - `src/ffi/index.ts`: `EncryptionClient` implementation, bridges to `@cipherstash/protect-ffi` @@ -82,6 +82,8 @@ If these variables are missing, tests that require live encryption will fail or - `packages/wizard`: AI-powered encryption setup (`@cipherstash/wizard`) - `packages/migrate`: Plaintext-to-encrypted column migration (`@cipherstash/migrate`) — resumable backfill, per-column state - `packages/prisma-next`: Prisma Next integration (`@cipherstash/prisma-next`) — searchable field-level encryption for Postgres +- `packages/stack-drizzle`: Drizzle ORM integration (`@cipherstash/stack-drizzle`), depends on `@cipherstash/stack` — EQL v2 (`.`) and EQL v3 (`./v3`). Split out of `@cipherstash/stack`. +- `packages/stack-supabase`: Supabase integration (`@cipherstash/stack-supabase`), depends on `@cipherstash/stack` — `encryptedSupabase` (v2) and `encryptedSupabaseV3` (v3). Split out of `@cipherstash/stack`. - `packages/schema`: Schema builder utilities and types (`encryptedTable`, `encryptedColumn`, `encryptedField`) - `packages/drizzle`: Drizzle ORM integration (`encryptedType`, `extractEncryptionSchema`, `createEncryptionOperators`) - `packages/nextjs`: Next.js helpers and Clerk integration (`./clerk` export) @@ -157,8 +159,8 @@ Three rules to remember when editing CI or pnpm config: - `encryptQuery(terms[])` for batch query encryption - **Identity-aware encryption**: Authenticate the client as the end user with `OidcFederationStrategy` (`config.strategy`, re-exported from `@cipherstash/stack`), then chain `.withLockContext({ identityClaim })` on operations to bind the data key to a claim. The same claim must be used for encrypt and decrypt. (`LockContext.identify()` from `@cipherstash/stack/identity` is deprecated — the strategy now handles token acquisition; `.withLockContext()` also accepts a `LockContext`.) - **Integrations**: - - **Drizzle ORM**: `encryptedType`, `extractEncryptionSchema`, `createEncryptionOperators` from `@cipherstash/stack/drizzle` - - **Supabase**: `encryptedSupabase` from `@cipherstash/stack/supabase` + - **Drizzle ORM**: `encryptedType`, `extractEncryptionSchema`, `createEncryptionOperators` from `@cipherstash/stack-drizzle` (EQL v3 factories from `@cipherstash/stack-drizzle/v3`) + - **Supabase**: `encryptedSupabase` (v2) / `encryptedSupabaseV3` (v3) from `@cipherstash/stack-supabase` - **DynamoDB**: `encryptedDynamoDB` from `@cipherstash/stack/dynamodb` ## Critical Gotchas (read before coding) @@ -174,9 +176,22 @@ Three rules to remember when editing CI or pnpm config: - **Formatting/Linting**: Use Biome ```bash -pnpm run code:fix +pnpm run code:fix # format + lint, auto-fixing what it can +pnpm run code:check # read-only; this is what CI runs ``` + CI runs `code:check` (in `tests.yml`) and gates on **errors** — warnings are + allowed (tracked for tightening). So `code:fix` must leave the tree + error-free before you push. + + A Biome GritQL plugin (`biome-plugins/no-type-erasing-assertions.grit`) warns + on `as any` / `as never` / `as unknown` in `src` — type-erasing assertions that + silence the checker instead of narrowing. Fix the type or use a specific + assertion; suppress a deliberate case with `// biome-ignore lint/plugin: + `. The plugin is scoped to source via an `overrides` entry in + `biome.json` (test/integration files excluded) — see the plugin file's header + for why it must be scoped-in rather than globally-enabled-and-exempted. + - **Build**: `pnpm run build` (Turborepo + tsup per package) - **Test**: `pnpm --filter test` for targeted iterations - **Releases**: Use Changesets diff --git a/SECURITY.md b/SECURITY.md index cbbb1e2f6..742c2f272 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -9,7 +9,7 @@ This repository is the CipherStash Stack monorepo for JavaScript/TypeScript. It | Package | Description | | ------- | ----------- | -| `@cipherstash/stack` | Main package: encryption client and all integrations | +| `@cipherstash/stack` | Main package: encryption client, schema, EQL v3 typed client | | `stash` | CipherStash CLI | | `@cipherstash/protect` | Core encryption library (re-exported via `@cipherstash/stack`) | | `@cipherstash/schema` | Schema builder utilities | @@ -18,6 +18,8 @@ This repository is the CipherStash Stack monorepo for JavaScript/TypeScript. It | `@cipherstash/protect-dynamodb` | DynamoDB helpers | | `@cipherstash/migrate` | Plaintext-to-encrypted column migration tooling | | `@cipherstash/prisma-next` | Prisma Next integration (searchable field-level encryption for Postgres) | +| `@cipherstash/stack-drizzle` | Drizzle ORM integration for `@cipherstash/stack` (EQL v2 + v3) | +| `@cipherstash/stack-supabase` | Supabase integration for `@cipherstash/stack` (EQL v2 + v3) | | `@cipherstash/wizard` | AI-powered encryption setup | **Security fixes are released for the latest release line of each package.** Security reports are welcome for any version, but fixes land in the latest release — if you are running an older major version, plan to upgrade to receive them. diff --git a/biome-plugins/no-type-erasing-assertions.grit b/biome-plugins/no-type-erasing-assertions.grit new file mode 100644 index 000000000..2aafe8a83 --- /dev/null +++ b/biome-plugins/no-type-erasing-assertions.grit @@ -0,0 +1,33 @@ +// Flags type-erasing assertions: `x as any`, `x as never`, `x as unknown` +// (the last also catches the inner half of `x as unknown as T` double-casts). +// +// These punch a hole through the type system rather than narrowing a value, so +// a real type mismatch can hide behind them (e.g. passing the wrong shape to a +// function whose signature you've silenced). Prefer fixing the underlying type, +// narrowing with a guard, or a precise `as SpecificType`. +// +// NOT flagged: `as const` (a widening-freeze, not an erasure), a plain +// `as SpecificType`, or `never` used as a *type annotation* (e.g. a contravariant +// `param: never`) — those are legitimate. +// +// Warning, not error: the repo has a large existing backlog, and this is a +// ratchet to keep NEW erasures visible. Intentional cases take a +// `// biome-ignore lint/plugin: ` suppression. +// +// Wiring note: this plugin is enabled via an `overrides` entry in biome.json +// that INCLUDES source globs and negates test globs — it is NOT enabled at the +// top level. Biome applies top-level `plugins` to every file, and +// `overrides[].plugins: []` does NOT disable them, so "enable globally + exempt +// tests" silently lints tests too. Scoping the plugin in via the override is the +// only way to exempt test doubles (which legitimately force-cast). +or { + `$e as any`, + `$e as never`, + `$e as unknown` +} where { + register_diagnostic( + span = $e, + message = "Avoid type-erasing assertions (`as any` / `as never` / `as unknown`) — they silence the checker instead of narrowing. Fix the underlying type, use a type guard, or assert a specific type. Suppress an intentional case with `// biome-ignore lint/plugin: `.", + severity = "warn" + ) +} diff --git a/biome.json b/biome.json index ca315148c..11e6da5bd 100644 --- a/biome.json +++ b/biome.json @@ -1,12 +1,21 @@ { - "$schema": "https://biomejs.dev/schemas/2.4.15/schema.json", + "$schema": "https://biomejs.dev/schemas/2.5.2/schema.json", "files": { "includes": [ "**", "!**/package.json", "!**/.turbo/", "!**/dist", - "!**/nix/store" + "!**/nix/store", + "!**/*.grit", + "!**/*.generated.ts", + "!**/contract.json", + "!**/contract.d.ts", + "!**/end-contract.json", + "!**/end-contract.d.ts", + "!**/migrations/**/migration.json", + "!**/migrations/**/ops.json", + "!**/migrations/**/refs" ] }, "formatter": { @@ -30,5 +39,20 @@ "noThenProperty": "off" } } - } + }, + "overrides": [ + { + "includes": [ + "**/src/**", + "examples/**", + "!**/__tests__/**", + "!**/*.test.ts", + "!**/*.test-d.ts", + "!**/*.spec.ts", + "!**/integration/**", + "!**/tests/**" + ], + "plugins": ["./biome-plugins/no-type-erasing-assertions.grit"] + } + ] } diff --git a/docs/eql-v3-ord-term-ordering-defect.md b/docs/eql-v3-ord-term-ordering-defect.md new file mode 100644 index 000000000..0c63425e4 --- /dev/null +++ b/docs/eql-v3-ord-term-ordering-defect.md @@ -0,0 +1,141 @@ +# EQL v3 non-superuser limitation: `ORDER BY eql_v3.ord_term(col)` does not sort in ORE order + +**Status:** Root-caused with live evidence. This is **not** a bug in our SDK and +not a defect in the EQL bundle — it is a **known platform limitation** of the +current (ORE-based) vendored EQL v3 bundle on non-superuser Postgres +(e.g. Supabase). The superuser gate on the ORE operator class is an intentional +install constraint so the bundle installs at all on managed Postgres, where an +ORE ordered index genuinely cannot exist. Our tests/docs are corrected to stop +relying on the construct that is silently wrong in that state; the resolution +(an upstream `_ord`→OPE migration) is tracked as a follow-up (see +[Resolution](#resolution)). + +## Summary + +For an encrypted ordering column (any `*_ord` / `text_search` domain), the range +comparison functions `eql_v3.gte`/`lte`/`lt`/`gt` sort **correctly** (true ORE +order), but on a non-superuser install `ORDER BY eql_v3.ord_term(col)` sorts +**incorrectly** — deterministic but not the ORE/lexical order. + +Reproduced against live Postgres (role `is_superuser = off`) with emails +`ada@example.com`, `grace@example.com`, `alan@example.net`, `zora@example.org`: + +| Construct | Result | Correct? | +|---|---|---| +| pairwise `eql_v3.lt(col, col)` (the ORE comparator) | `ada < alan < grace < zora` | ✅ ORE/lexical | +| `ORDER BY eql_v3.ord_term(col)` | `zora, alan, ada, grace` | ❌ record_ops | +| `ORDER BY col` (domain default) | `grace, ada, alan, zora` (structural) | ❌ jsonb_ops | +| `ORDER BY col USING <` / `USING OPERATOR(public.<)` | error: *operator < is not a valid ordering operator* | ❌ no orderable family | + +So on a non-superuser install there is **no** `ORDER BY` construct that yields +ORE order. Only the boolean comparison operators (used in `WHERE` predicates) are +ORE-correct — and they are correct regardless of superuser. + +## Why this happens on Supabase + +File: the EQL v3 install bundle shipped by `@cipherstash/eql`, at +`node_modules/@cipherstash/eql/dist/sql/cipherstash-encrypt.sql` (or via +`installSqlPath()` from `@cipherstash/eql/sql`). Generated upstream — never +hand-edit; bump the pinned package version instead. + +Line numbers below were recorded against the bundle vendored at the time of +writing and are indicative only; the released bundle orders its source files +differently. Locate the definitions by name. + +1. `eql_v3.ord_term(a public.text_search)` (and every `*_ord` domain, e.g. + `public.integer_ord` at line 18117) returns the **composite** type + `eql_v3_internal.ore_block_256` — line **38141-38144**: + ```sql + CREATE FUNCTION eql_v3.ord_term(a public.text_search) + RETURNS eql_v3_internal.ore_block_256 ... + ``` + `ore_block_256` is `CREATE TYPE ... AS (terms eql_v3_internal.ore_block_256_term[])` + at line **193**. + +2. The ORE-correct default btree opclass for that composite type, + `eql_v3_internal.ore_block_256_operator_class` (backed by + `eql_v3_internal.compare_ore_block_256_terms`), is created inside a + superuser-gated `DO` block — lines **3117-3138**. Creating an operator + class requires superuser, so on managed/non-superuser Postgres it is + **intentionally skipped** on `insufficient_privilege` (lines 3134-3136): + ``` + EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class + (requires superuser); ORE ordered indexes on ore_block_256 unavailable ... + ``` + This gate is deliberate: it is what lets the EQL v3 bundle install cleanly on + Supabase and other non-superuser platforms, where an ORE ordered index cannot + exist at all. Live check confirms: + `SELECT ... FROM pg_opclass ... WHERE typname='ore_block_256'` returns `[]`. + +3. With the opclass absent, `ORDER BY eql_v3.ord_term(col)` still "works" + because PostgreSQL supplies a built-in **record comparison** for any + composite type. That compares the `ore_block_256_term[]` fields by their raw + bytes — deterministic, but unrelated to ORE order. This is the silent-wrong + footgun: it does not error, it just sorts wrong. + +4. Meanwhile `eql_v3.gte/lte/lt/gt` are ORE-correct **regardless of superuser** + because they do not go through index/sort machinery. `eql_v3.lt(text_search)` + (line 38206) is `SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)`, and the + `public.<` operator on `ore_block_256` is wired directly to + `eql_v3_internal.compare_ore_block_256_terms`. The domain-level `<` operator + (`CREATE OPERATOR <`, line 38566, `FUNCTION = eql_v3.lt`) exists, but it is + **not** a member of any btree operator family, so `ORDER BY col USING <` + raises "operator < is not a valid ordering operator". + +The bundle comment (lines 3104-3114) documents the missing opclass as the +accepted managed-Postgres limitation ("ORE ordered scans ... unavailable"). The +practical consequence to be aware of is that `ORDER BY ord_term(col)` **silently +returns wrong results** in that state instead of failing, and there is no +non-superuser ORE ordering path on the current bundle. + +## Minimal repro + +```sql +-- role without superuser; EQL v3 bundle installed +CREATE TABLE t (email public.text_search NOT NULL, label text); +-- insert encrypted 'ada@example.com','grace@example.com', +-- 'alan@example.net','zora@example.org' (labels ada/grace/alan/zora) + +SELECT current_setting('is_superuser'); -- off +SELECT count(*) FROM pg_opclass c JOIN pg_type ty + ON ty.oid=c.opcintype WHERE ty.typname='ore_block_256'; -- 0 + +SELECT label FROM t ORDER BY eql_v3.ord_term(email); -- zora,alan,ada,grace (WRONG) +-- vs the ORE comparator, which is correct: +SELECT x.label, y.label, eql_v3.lt(x.email, y.email) FROM t x CROSS JOIN t y; -- ada eql_v3.ord_term(col)` for a future v3 + Drizzle/Prisma adapter (e.g. + `docs/superpowers/2026-06-12-eql-v3-drizzle-adapter-walkthrough.md`, + `docs/superpowers/plans/2026-07-06-eql-v3-drizzle-concrete-types.md`) would hit + this limitation on the current ORE bundle if implemented as written. Any v3 + `orderBy` must not lower to a bare `ORDER BY ord_term(...)` on the current ORE + bundle; once the OPE `_ord` migration lands, `ORDER BY` on `_ord` becomes + correct everywhere. diff --git a/docs/plans/2026-07-13-adapter-package-split.md b/docs/plans/2026-07-13-adapter-package-split.md new file mode 100644 index 000000000..f3cd9701d --- /dev/null +++ b/docs/plans/2026-07-13-adapter-package-split.md @@ -0,0 +1,115 @@ +# Adapter package split — execution plan (#627) + +Extract the Supabase and Drizzle integrations out of `@cipherstash/stack` into +their own packages (`@cipherstash/stack-supabase`, `@cipherstash/stack-drizzle`), +each depending on stack via `workspace:*`, following the `@cipherstash/prisma-next` +precedent. Tracked in #627; PR1's integration harness (#616) is merged, which is +the safety net this refactor wanted behind it. + +## Status + +- **DONE (committed on this branch):** the enabling support surface + `@cipherstash/stack/adapter-kit` — a single narrow entry re-exporting exactly the + core internals the adapters consume. Builds; all re-exported values resolve. +- **STAGED (this plan):** the mechanical move of the adapter code + tests into the + two new packages. Deliberately left for an **attended** session — it touches + ~35 files across a package boundary and each import rewrite / test move is a live + breakage point best caught interactively, not overnight. + +## The design decision (needs sign-off) + +The plan's own risk note said the "expose internal modules vs relocate them" call +is *"a design call to make before coding."* Made here, defaulted to **expose**, and +kept as small and reversible as possible: + +> Rather than leak six internal module paths (`@/utils/logger`, +> `@/encryption/helpers`, `@/encryption/operations/base-operation`, +> `@/eql/v3/columns`, `@/eql/v3/domain-registry`, `@/schema/match-defaults`) into +> the public surface, **one** new subpath — `@cipherstash/stack/adapter-kit` — +> re-exports exactly the symbols the adapters use. It is documented as the +> core↔first-party-adapter seam, not general-purpose public API. + +The internal `@/types` symbols the adapters need (`BulkEncryptedData`, +`ClientConfig`, `Encrypted`, `QueryTypeName`, `queryTypes`) are **already** in the +public `./types` — so they need no new surface; the move repoints those imports to +`@cipherstash/stack/types`. `AnyEncryptedV3Column` is already in `./eql/v3`. + +**If you'd rather relocate** (e.g. move `logger` to `@cipherstash/utils`, the v3 +column/registry pieces to `@cipherstash/schema`) than expose `adapter-kit`, say so +and the move repoints accordingly — the mechanical steps below are unchanged. + +## Verified import surface (what the adapters pull from core) + +| Import (was `@/…`) | Move to | Symbols | +|---|---|---| +| `@/types` | `@cipherstash/stack/types` | `BulkEncryptedData`, `ClientConfig`, `Encrypted`, `QueryTypeName`, `queryTypes` | +| `@/errors` | `@cipherstash/stack/errors` | (errors) | +| `@/identity` | `@cipherstash/stack/identity` | `LockContext` | +| `@/schema` | `@cipherstash/stack/schema` | `EncryptedColumn`, `EncryptedTable`, … | +| `@/eql/v3` | `@cipherstash/stack/eql/v3` | v3 table/column API, `AnyEncryptedV3Column` | +| `@/encryption`, `@/encryption/index.js` | `@cipherstash/stack` | `Encryption`, `EncryptionClient` | +| `@/utils/logger` | `@cipherstash/stack/adapter-kit` | `logger` | +| `@/encryption/helpers` | `@cipherstash/stack/adapter-kit` | `bulkModelsToEncryptedPgComposites`, `modelToEncryptedPgComposites` | +| `@/encryption/operations/base-operation` | `@cipherstash/stack/adapter-kit` | `AuditConfig` | +| `@/eql/v3/columns` | `@cipherstash/stack/adapter-kit` | `EncryptedV3Column`, `DATE_LIKE_CASTS` (+ `AnyEncryptedV3Column` via `./eql/v3`) | +| `@/eql/v3/domain-registry` | `@cipherstash/stack/adapter-kit` | `DOMAIN_REGISTRY`, `factoryForDomain`, `stripDomainSchema` | +| `@/schema/match-defaults` | `@cipherstash/stack/adapter-kit` | `matchNeedleError` | + +The adapters are **leaf modules** — nothing in `packages/stack/src` outside the +adapter dirs imports them — so removing them does not break core. + +## File inventory to move + +- **stack-supabase:** `packages/stack/src/supabase/*` (8 files: `helpers`, + `index`, `introspect`, `query-builder`, `query-builder-v3`, `schema-builder`, + `types`, `verify`). Unit tests: the `supabase*` files under + `packages/stack/__tests__/` (~13). Integration: `packages/stack/integration/supabase/`. +- **stack-drizzle:** `packages/stack/src/drizzle/*` (v2) **and** + `packages/stack/src/eql/v3/drizzle/*`. Unit tests: `drizzle*` under + `packages/stack/__tests__/` + `__tests__/drizzle-v3/`. Integration: + `packages/stack/integration/drizzle-v3/`. + +## Phased steps (per package; do Supabase first as the proven slice) + +1. Scaffold the package (`package.json` with `@cipherstash/stack: workspace:*` + + `@cipherstash/protect-ffi` at stack's pinned version, `pg`/`@types/pg` if + introspection needs them; `tsconfig.json`, `tsup.config.ts`, `vitest.config.ts` + — copy prisma-next's shape). Export `.` (the adapter entry). +2. `git mv` the src dir(s) into the package. +3. Rewrite imports per the table above (`@/…` → `@cipherstash/stack[/subpath]`). + Relative imports within the moved tree stay as-is. +4. Remove the adapter's subpath from stack: `exports`, `typesVersions`, + `tsup.config.ts` entry. (`./supabase`, `./drizzle`, `./eql/v3/drizzle`.) +5. Build stack, then the new package (src only). Get green before touching tests. +6. Move the unit + integration test files; rewrite their imports (watch for tests + that reach stack `__tests__/helpers/**` — those helpers may need to move to + `@cipherstash/test-kit` or be duplicated). Wire the package's vitest config + + integration config against `@cipherstash/test-kit`. +7. Update the `fta-v3.yml` complexity gate: its `analyze:complexity` scans + `packages/stack/src/eql/v3`; update the path filter and add an equivalent gate + in stack-drizzle so the moved code keeps its budget. +8. Update doc/skill references (~13 for `@cipherstash/stack/drizzle`, plus the + Supabase reference docs and `skills/stash-supabase` / `skills/stash-drizzle`) — + these ship in the `stash` tarball. +9. Changesets: breaking (removed subpaths from stack) + new-package changesets. + +## Verification checklist + +- `pnpm --filter @cipherstash/stack build` + `test:types` green (core still builds + with the subpaths removed). +- `pnpm --filter @cipherstash/stack-supabase build && … test` green; same for + stack-drizzle. +- `pnpm -w build` green (no dependency cycle: stack must not import the adapters). +- `pnpm install --frozen-lockfile` clean. +- The two integration workflows point at the moved suites. +- `stash manifest --json` unaffected (CLI surface unchanged by this refactor). + +## Open questions for review + +1. Approve the `adapter-kit` expose approach, or prefer relocation for specific + symbols (esp. `logger` → `@cipherstash/utils`)? +2. Package names: `@cipherstash/stack-supabase` / `@cipherstash/stack-drizzle` + (matches the plan) — confirm. +3. Version/`publishConfig`: start both at `0.1.0`, `access: public`? +4. Test-helper coupling: move shared `__tests__/helpers/**` into + `@cipherstash/test-kit`, or duplicate the few the adapters need? diff --git a/docs/reference/supabase-sdk.md b/docs/reference/supabase-sdk.md index 4698b4e69..6561f255e 100644 --- a/docs/reference/supabase-sdk.md +++ b/docs/reference/supabase-sdk.md @@ -1,6 +1,6 @@ # Supabase SDK reference -`@cipherstash/stack/supabase` wraps a supabase-js client so encrypted columns +`@cipherstash/stack-supabase` wraps a supabase-js client so encrypted columns are transparently encrypted on mutations, `::jsonb`-cast on selects, encrypted in filter terms, and decrypted in results. @@ -9,64 +9,91 @@ Two entry points, one query mechanism: | Entry point | Schema DSL | Column storage | |---|---|---| | `encryptedSupabase` | `@cipherstash/stack/schema` (EQL v2) | `eql_v2_encrypted` composite | -| `encryptedSupabaseV3` | `@cipherstash/stack/eql/v3` (EQL v3) | native `eql_v3.*` domains | +| `encryptedSupabaseV3` | `@cipherstash/stack/eql/v3` (EQL v3) | native `public.eql_v3_*` domains | Both filter via **direct EQL operators over PostgREST**: the wrapper encrypts the filter term and emits an ordinary `col term` filter, which resolves to the custom operator defined on the encrypted type (equality by HMAC, range -by ORE, free-text by bloom-filter containment). +by the ordering term — CLLW-OPE on `_ord` domains, block-ORE on `_ord_ore` — +free-text by bloom-filter containment). ## Quick start (EQL v3) -```typescript -import { Encryption } from '@cipherstash/stack' -import { encryptedTable, types } from '@cipherstash/stack/eql/v3' -import { encryptedSupabaseV3 } from '@cipherstash/stack/supabase' -import { createClient } from '@supabase/supabase-js' +`encryptedSupabaseV3` is an async factory that **introspects the database at +connect time**: it detects EQL v3 columns by their Postgres domain, derives +each column's encryption config from the domain, and builds the encryption +client internally. Introspection needs a direct Postgres connection +(`options.databaseUrl`, defaulting to `DATABASE_URL`), so the factory cannot +run in a Worker or the browser. -const users = encryptedTable('users', { - email: types.TextSearch('email'), // eql_v3.text_search - amount: types.IntegerOrd('amount'), // eql_v3.integer_ord -}) +```typescript +import { encryptedSupabaseV3 } from '@cipherstash/stack-supabase' -const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_ANON_KEY!) -const client = await Encryption({ schemas: [users] }) -const es = encryptedSupabaseV3({ encryptionClient: client, supabaseClient: supabase }) +// Introspects the database via options.databaseUrl or DATABASE_URL +const es = await encryptedSupabaseV3( + process.env.SUPABASE_URL!, + process.env.SUPABASE_ANON_KEY!, +) +// or wrap an existing client: await encryptedSupabaseV3(supabaseClient, options) -await es.from('users', users).insert({ email: 'a@b.com', amount: 30 }) +await es.from('users').insert({ email: 'a@b.com', amount: 30 }) const { data } = await es - .from('users', users) + .from('users') .select('id, email, amount') .eq('email', 'a@b.com') -await es.from('users', users).select('id, amount').gte('amount', 10).lte('amount', 100) +await es.from('users').select('id, amount').gte('amount', 10).lte('amount', 100) ``` -The builder surface is identical across v2 and v3: +`from(tableName)` takes only the table name — no schema argument; column +capabilities come from the introspected domains. + +The builder surface is shared across v2 and v3: `.select/.insert/.update/.upsert/.delete`, -`.eq/.neq/.in/.like/.ilike/.is/.gt/.gte/.lt/.lte/.match/.or/.not/.filter`, +`.eq/.neq/.in/.is/.gt/.gte/.lt/.lte/.match/.or/.not/.filter`, transforms (`.order/.limit/.range/.single/.maybeSingle/.csv/.abortSignal/.throwOnError`), -plus `.withLockContext(lockContext)` and `.audit(config)`. +plus `.withLockContext(lockContext)` and `.audit(config)` — with one fork: +free-text search. v2 exposes `.like/.ilike` (SQL wildcard matching); v3 +exposes `.matches()` (fuzzy bloom token search) on encrypted columns, keeps +`.contains()` for native (exact) containment on plaintext columns, and treats +`like`/`ilike` on an encrypted column as an approximate shim that delegates to +`.matches()` (see "v3 encoding details" below). ### Typing (v3) -`es.from('users', users)` infers rows as **exactly** the table's plaintext +Declared schemas are optional. Passing `schemas` — a record whose keys must +equal each table's name — adds compile-time types and verifies the declared +tables against the database at construction: + +```typescript +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { encryptedSupabaseV3 } from '@cipherstash/stack-supabase' + +const users = encryptedTable('users', { + email: types.TextSearch('email'), // public.eql_v3_text_search + amount: types.IntegerOrd('amount'), // public.eql_v3_integer_ord +}) + +const es = await encryptedSupabaseV3( + process.env.SUPABASE_URL!, + process.env.SUPABASE_ANON_KEY!, + { schemas: { users } }, +) +``` + +`es.from('users')` then infers rows as **exactly** the table's plaintext shape (schema columns get their domain plaintext types — `types.IntegerOrd` → `number`, `types.TimestampOrd` → `Date`, …). Storage-only columns (e.g. `types.Boolean`) are excluded from every filter method — including `.match()` — -at the type level; filtering one is always a clear runtime error. +at the type level, `matches()` is narrowed to match-indexed columns, and +`order()` to plaintext columns; filtering a storage-only column is always a +clear runtime error. Undeclared tables behave exactly as with no `schemas` at +all: `from(tableName)` returns the untyped v3 builder, with `Row` +defaulting to `Record`. -Plaintext passthrough columns (`id`, `created_at`, …) are not part of the -default row type, so filtering or inserting them needs an explicit row type -(deliberate: widening the default with an index signature would silently -disable the storage-only guard): - -```typescript -type UserRow = { id: number; email: string; amount: number } -const builder = es.from('users', users) -builder.eq('id', 1) // ok — id is in UserRow -``` +Every v3 column is fully described by its `types.*` factory — there are no +capability or tuning chains on v3 columns. ### Property ↔ DB column names (v3) @@ -90,15 +117,15 @@ to real `Date` objects (reconstructed from the encrypt-config `cast_as`). ```sql CREATE TABLE users ( id SERIAL PRIMARY KEY, - email eql_v3.text_search, - amount eql_v3.integer_ord, - created_at eql_v3.timestamp_ord + email public.eql_v3_text_search, + amount public.eql_v3_integer_ord, + created_at public.eql_v3_timestamp_ord ); ``` -The `types.*` member name maps to the domain name: strip the `eql_v3.` prefix -and PascalCase each `_`-separated segment (`types.TextEq` → `eql_v3.text_eq`, -`types.IntegerOrd` → `eql_v3.integer_ord`, `types.Timestamp` → `eql_v3.timestamp`). +The `types.*` member name maps to the flat domain name: strip the `eql_v3_` +prefix and PascalCase each `_`-separated segment (`types.TextEq` → `public.eql_v3_text_eq`, +`types.IntegerOrd` → `public.eql_v3_integer_ord`, `types.Timestamp` → `public.eql_v3_timestamp`). The domains use SQL-standard type names (`integer`, `smallint`, `real`, `double`, `boolean`, `timestamp`). @@ -112,35 +139,46 @@ stash eql install --supabase stash eql install --eql-version 3 --supabase ``` -The `--supabase` install uses the opclass-stripped bundle (operator classes / -families require superuser, which Supabase does not grant) and applies the -schema grants for `anon`, `authenticated`, and `service_role`. Without the -grants, encrypted queries fail with `42501`. - -The vendored v3 bundle is the [`eql-3.0.0-alpha.2`](https://github.com/cipherstash/encrypt-query-language/releases/tag/eql-3.0.0-alpha.2) -release artifact. It installs two schemas: `eql_v3` (the column domains and -operators) and `eql_v3_internal` (SEM internals — support functions and types -the domains depend on). The installer applies role grants to **both** schemas; -`eql_v3_internal` needs the grants but must never be exposed (see below). - -### Exposed schemas (manual, required) - -For a bare `col term` filter to reach the custom operator, the EQL schema -(`eql_v2` for v2, `eql_v3` for v3) must be on PostgREST's request-time -search_path — add it to **Dashboard → Settings → API → Exposed schemas** +For **v2**, `--supabase` selects the opclass-stripped bundle (operator +classes / families require superuser, which Supabase does not grant) and +applies the schema grants for `anon`, `authenticated`, and `service_role`. +Without the grants, encrypted queries fail with `42501`. + +For **v3**, since eql-3.0.0 there is **one** SQL artifact for every target — +no separate Supabase variant. The bundle's only superuser-requiring +statements (the `ore_block_256` operator class/family) self-skip on +`insufficient_privilege`, and the bundle then disables the ORE-opclass-backed +domains it cannot support (CIP-3468) — so the same bundle installs with or +without `--supabase`. The flag changes one thing: it additionally applies the +role grants for `anon` / `authenticated` / `service_role`. + +The vendored v3 bundle is the `eql-3.0.0` release artifact. It installs two +schemas: `eql_v3` (index-term extractors and the operator-backing comparison +functions) and `eql_v3_internal` (SEM internals — support functions and types +the domains depend on); the column domains themselves live in `public`. The +installer applies role grants to **both** EQL schemas; `eql_v3_internal` +needs the grants but must never be exposed (see below). Without the grants, +encrypted queries fail loudly with a permission error (e.g. `permission +denied for schema eql_v3_internal`). + +### Exposed schemas + +**v2 (manual, required):** for a bare `col term` filter to reach the +custom operator, `eql_v2` must be on PostgREST's request-time search_path — +add it to **Dashboard → Settings → API → Exposed schemas** ([Supabase custom-schemas guide](https://supabase.com/docs/guides/api/using-custom-schemas)). -For v3, expose `eql_v3` **only**. SEM internals live in a separate -`eql_v3_internal` schema precisely so that exposing `eql_v3` (and Supabase's -Table-Builder type picker) surfaces just the column domains — do not add -`eql_v3_internal` to Exposed schemas. It still receives role grants (the -installer applies them); grants and exposure are independent. +> **Warning — silent fallback (v2).** If the schema is not exposed, the +> operators do not error: comparisons silently fall back to the base jsonb +> operators and return **wrong rows with no error**. After changing the +> setting, verify with a known-value round-trip: insert a row, filter for it +> by an encrypted column, and assert the hit. -> **Warning — silent fallback.** If the schema is not exposed, the operators -> do not error: comparisons silently fall back to the base jsonb operators and -> return **wrong rows with no error**. After changing the setting, verify with -> a known-value round-trip: insert a row, filter for it by an encrypted -> column, and assert the hit. +**v3 (no change needed):** the column domains and their operators live in +`public`, so bare `col term` filters resolve under Supabase's default +PostgREST configuration. Do not add `eql_v3_internal` (or `eql_v3`) to +Exposed schemas — the role grants are what matter, and grants and exposure +are independent. ## v3 encoding details @@ -148,53 +186,69 @@ These are internal to the adapter but explain observable behaviour. Envelopes (stored payloads and filter operands alike) are versioned `v: 3`. - **INTERIM — filter operands are full storage envelopes.** This is a - workaround, not the design, and it is tracked for replacement - (Linear **CIP-3402**). Why it is required today: every `eql_v3.*` domain - CHECK requires the storage keys (`v`/`i`/`c` plus the domain's index terms: - `hm` for `text_eq`, `ob` for `integer_ord`, all three for `text_search`), - and the SQL operator functions coerce their jsonb operand into the domain. - A narrowed query-only term (no ciphertext) fails the CHECK with `23514` for - every domain, so the adapter encrypts each filter value with the full - storage path and the operators extract the term they need - (`eq_term`/`ord_term`/`match_term`). + workaround, not the design, and the adapter-side fix is tracked + (Linear **CIP-3402**). The term-only wire shape now exists: the bundle + defines an `eql_v3.query_` companion domain for each storage domain, + whose CHECK accepts exactly the no-ciphertext shape, and protect-ffi 0.29's + `encryptQuery` can mint those narrowed operands. But they are unreachable + from this adapter: PostgREST has no syntax to cast a filter value, and an + uncast literal is ambiguous between the query-domain and `jsonb` operator + overloads (`42725`), so the reachable overload is the `jsonb` one — whose + body coerces its operand into the STORAGE domain, whose CHECK requires the + storage keys (`v`/`i`/`c` plus the domain's index terms: `hm` for + `text_eq`, `op` for `integer_ord`, `hm`+`op`+`bf` for `text_search`). So the + adapter encrypts each filter value with the full storage path and the + operators extract the term they need (`eq_term`/`ord_term`/`match_term`). **Security caveat:** query terms are supposed to be index-terms-only by design, but a full-envelope operand carries a real, decryptable ciphertext `c` plus **all** of the column's index terms — and PostgREST filters travel in GET query strings, so these envelopes can land in URL logs, intermediate - proxies, and Supabase request logs. The planned fix is an EQL-side - **term-only scalar query envelope** (the scalar analog of the existing - `eql_v3.jsonb_query`) that the domains/operators accept without storage - keys; once it ships, operands stop carrying ciphertext. -- **`like`/`ilike` are emitted as PostgREST `cs`** (`@>` bloom containment) — - the v3 domains define no LIKE operator. Match is tokenized + downcased, so - `like` and `ilike` behave identically; do not include `%` wildcards. -- **INTERIM — free-text search needs `include_original: false`** on the - column's match index for substring patterns to match: - - ```typescript - types.TextSearch('email').freeTextSearch({ include_original: false }) - ``` - - With the default `include_original: true`, the full-envelope operand's bloom - carries the whole pattern as an extra token that only matches when the - pattern equals the stored value. This requirement is a symptom of the same - full-envelope interim mechanism above — a term-only query envelope encodes - the pattern as a query (not as a stored value), so the requirement goes away - with CIP-3402. + proxies, and Supabase request logs. The remaining gap is PostgREST operand + casting; until the adapter can reach the query domains (CIP-3402), operands + keep carrying ciphertext. +- **Free-text search is `matches()`; `contains()` on an encrypted column is + rejected** with an error naming `matches()`. The v3 domains define no LIKE + operator — encrypted free-text search is fuzzy bloom-filter token matching + (`matches()` → PostgREST `cs` → `@>`), one-sided (a match may be a false + positive, a non-match never is) and order-/multiplicity-insensitive, where + match is tokenized + downcased and `%` is tokenized like any other character. + `contains()` is reserved for native (exact) jsonb/array containment on + plaintext columns, which pass through unchanged. +- **`like`/`ilike` on an encrypted column are an approximate compatibility + shim** that delegates to `matches()`: leading/trailing `%` are stripped and + the residual term is fuzzy-matched (emitting the same `cs` wire, with a + one-time warning). Because the match is case-insensitive, one-sided, and + anchoring is not honored, the result is APPROXIMATE. A pattern with an + internal `%` or any `_` cannot be approximated and throws; call `matches()` + directly to make the fuzzy intent explicit. On plaintext columns `like`/`ilike` + pass through unchanged as real SQL LIKE. +- **`matches()` matches substrings.** The search term blooms to its own + trigrams, and a row matches when the stored value's bloom contains all of + them — so any substring of at least 3 characters (the tokenizer's + `token_length`) matches. Shorter terms bloom to nothing and would match every + row, so they are rejected with an error rather than answered. +- **`select('*')` (and bare `select()`) works on v3** — it expands to the + introspected column list, with encrypted columns aliased and `::jsonb`-cast. - **Mutations send the raw encrypted payload** (the domains are `DOMAIN … AS jsonb`), unlike v2's `{ data: … }` composite wrap. - **Null filter values are rejected** with a pointer to `.is(column, null)` — a null cannot be encrypted into an operand, and silently passing it through would compare against the jsonb literal `null`. -## Caveats (shared by v2 and v3) - -- **No `ORDER BY` on encrypted columns.** Operator families need superuser, so - the Supabase install ships without index acceleration and without an - orderable opclass. Range *filtering* (`WHERE col >= term`) works; sorting - does not. OPE index terms that are natively orderable on Supabase (btree + - `ORDER BY`, built-in comparison) are in active development. -- **`select('*')` is rejected** — list columns explicitly so encrypted columns - can be cast. -- **Operator visibility depends on the Exposed-schemas step** (above). +## Caveats + +- **No `ORDER BY` on encrypted columns (v2 and v3).** Range *filtering* + (`WHERE col >= term`) works in both; sorting does not. + - v2: operator families need superuser, so the Supabase install ships + without an orderable opclass. + - v3: the bundle deliberately declares no btree operator class on any + domain, so a bare `ORDER BY` would silently sort the raw ciphertext + envelope. Correct ordering is `ORDER BY eql_v3.ord_term(col)`, which + PostgREST's `order=` parameter cannot express — the v3 builder therefore + rejects `order()` on any encrypted column (including range-capable ones) + with a clear error. +- **`select('*')` is rejected on v2** — list columns explicitly so encrypted + columns can be cast. (v3 expands `'*'` from the introspected column list.) +- **v2 operator visibility depends on the Exposed-schemas step** (above); v3 + needs only the role grants. diff --git a/docs/superpowers/plans/2026-07-10-eql-v3-integration-tests.md b/docs/superpowers/plans/2026-07-10-eql-v3-integration-tests.md new file mode 100644 index 000000000..9eb30fd2e --- /dev/null +++ b/docs/superpowers/plans/2026-07-10-eql-v3-integration-tests.md @@ -0,0 +1,331 @@ +# EQL v3 Integration Test Suite Plan (tests → type robustness → packaging → JSON) + +> **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:** Give every EQL v3 adapter a **comprehensive, real-crypto integration suite** that proves query correctness against a real database — for each domain type, generate a sample of plaintext, single-encrypt some rows and bulk-encrypt the rest, insert them through the adapter, then exercise every valid query operation over a range of values and assert against a plaintext oracle. Then, standing on that suite, restore the erased EQL v3 types, split the adapters into their own packages, and add v3 JSON support. + +**Architecture:** One capability catalog, one plaintext oracle, one driver. Everything is **derived from `V3_MATRIX`**, never hand-listed: which operations must work, which must be rejected, which rows to seed. The catalog is `satisfies Record` keyed off the real `AnyEncryptedV3Column` union, so adding a domain to the SDK fails compilation until a catalog row exists. A single `IntegrationAdapter` interface abstracts Drizzle from Supabase, so each per-family test file is three lines and the two adapters cannot drift in what they claim to cover. Integration tests are **separate from unit tests** — own vitest config, own `test:integration` script, own CI workflow — and they **fail loudly** rather than skipping when credentials or a database are absent. EQL v3 is installed by the real `stash eql install --eql-version 3` CLI, so an installer regression fails CI instead of hiding behind a test-only code path. + +**Tech Stack:** TypeScript, `vitest` (`vitest run --config vitest.integration.config.ts`), `@cipherstash/stack` (`/eql/v3` catalog, `/v3` typed client, `/supabase`, `/eql/v3/drizzle`), `@cipherstash/eql@3.0.0` (canonical wire types; `/sql` release manifest), `@cipherstash/protect-ffi@0.29`, `postgres` (direct DDL), `@supabase/postgrest-js`, `drizzle-orm`, `stash` CLI (`packages/cli`), Docker (`ghcr.io/cipherstash/postgres-eql:17-2.3.1`, `supabase/postgres`, `postgrest/postgrest:v12.2.12`), `turbo`, `biome`. + +## Global Constraints + +1. **No `describe.skipIf` in integration suites.** A false gate is a silent whole-suite skip on a green job. Missing credentials, database, or PostgREST must throw with an actionable message. `AutoStrategy` lets a local `~/.cipherstash` profile stand in for `CS_*` env vars, so local dev stays frictionless. +2. **`pnpm test` must never run integration tests.** They live behind `test:integration` and their own workflows. +3. **Coverage is compile-enforced.** `V3_MATRIX` must keep its `satisfies Record`, and the test kit must be typechecked in CI, or a new domain silently goes untested. +4. **The oracle is the plaintext**, never a restatement of the query. Expected row sets are computed by filtering the seeded plaintext with `comparePlain`, not by asserting a literal. +5. **Never assert `localeCompare` ordering.** Strings compare by codepoint, dates by instant, bigints numerically. +6. **Connect direct to port 5432, never a pooler.** The `SET ROLE` / advisory-lock flakiness seen in `supabase-v3-grants-pg` is a PgBouncer transaction-mode artifact. + +## Ground-truth notes (verified against `feat/eql-v3-text-search-schema`, 2026-07-10) + +- **The Supabase v3 adapter has zero real-crypto coverage.** `packages/stack/__tests__/supabase-v3-pgrest-live.test.ts` runs against a real PostgREST but stubs ZeroKMS. Its equality term is `` `hm-${value}` `` (`__tests__/helpers/v3-envelope.ts:22`), so `.in('nickname', ['ada','nobody']) → ['ada']` is true by construction. The file header says as much: "What is faked is ZeroKMS — and only ZeroKMS." +- **`drizzle-v3/operators-live-pg.test.ts` is a genuine end-to-end suite** across all covered domains — real `EncryptionV3`, real Postgres, known rows, plaintext oracle (`plainValue`, `comparePlain`, `expectedKeysFor`, `sortedKeysFor`). It seeds **only** via `bulkEncryptModels`; the single-`encryptModel` insert path is never exercised. +- **The Supabase `insert()` branches on shape**: array → `bulkEncryptModels` (`query-builder.ts:452`), single object → `encryptModel` (`:474`). The live suite only ever inserts a single object, so the array path is untested. +- **The canonical EQL v3 types are imported nowhere.** `@cipherstash/eql@3.0.0` exports ~130 per-domain types (`IntegerOrd = { v, i, c, op: OpeCllw }` and its term-only twin `IntegerOrdQuery = { v, i, op }`), but no `.ts` source file imports them; only `@cipherstash/eql/sql` is consumed. Both adapters erase to `unknown`: `eql/v3/drizzle/operators.ts:51,55` type the client's `encrypt`/`bulkEncrypt` as returning `unknown`; `encryptOperands` returns `Promise`; `supabase/query-builder-v3.ts:393,433,463` do the same, and the `Result` wrapper collapses to `{ data?: unknown }`. +- **v3 JSON is unimplemented, not merely untested.** The bundle ships `public.eql_v3_json` and `public.eql_v3_jsonb_entry` (51 `CREATE DOMAIN`s, 56 `eql_v3.{ste_vec,jsonb_path,selector,contained_by}` functions), but the SDK models 41 domains and `eql/v3/columns.ts` admits only `bigint | boolean | date | number | string | timestamp` as `cast_as`. There is no `'json'` kind, so a v3 JSON column cannot be declared. **The gap is in the core v3 schema; both adapters inherit it.** `eql/v3/drizzle/codec.ts:38` already carries defensive SteVec decode logic (`sv[0].c`) for documents nothing can currently create. +- **`@cipherstash/stack/drizzle` is not `@cipherstash/drizzle`.** They are a fork: `@cipherstash/drizzle@3.0.3` peer-depends on the predecessor SDK `@cipherstash/protect@12` and exports `createProtectOperators` (2,038 lines); stack's in-tree copy exports `createEncryptionOperators` (1,945 lines); ~645 lines have diverged. There is no dependency between them — hence no cycle today, only duplication. Docs reference the stack subpath 13× and the package 2×. +- **Ordering is safe on OPE.** EQL 3.0.0 pins `_ord` domains to `op` (CLLW-OPE), which orders via a native `bytea` btree, so `ORDER BY eql_v3.ord_term(col)` works on every provider without superuser. +- **`_ord_ore` columns cannot hold data on managed Postgres — and that is correct.** Measured against `supabase/postgres:17.4.1.048`, EQL 3.0.0, as the non-superuser `postgres` role: the nine ORE domains are created, but their CHECK calls `eql_v3_internal.ore_domain_unavailable()`, so the first `INSERT` raises with a hint naming `_eq` / `_ord` / `_ord_ope` as alternatives. The same insert succeeds on plain Postgres as a superuser. The bundle guards correctly; there is no silent wrongness. (An earlier draft of this plan claimed ORDER BY silently mis-sorts. It does at the *type* level — `ore_block_256` is a composite type, so with no opclass Postgres falls back to record comparison — but no value can reach a table to be ordered. `cipherstash/encrypt-query-language#395` records the correction.) A matrix that must pass on both databases cannot cover ORE, because the seed insert fails on one; ORE gets a superuser-only suite. +- **Supabase CAN order encrypted `_ord` columns.** A bare `ORDER BY col` sorts the ciphertext envelope through jsonb's default opclass (measured: `r00,r04,r08,r01,…` for plaintext `r00..r09`). But `eql_v3.ord_term` returns the `op` term, OPE is order-preserving, and PostgREST can emit the jsonb path `order=col->>op`, which reproduces plaintext order in both directions for `integer_ord` and `text_search`. The adapter now does exactly that, and rejects only ORE-backed and ordering-less columns. +- **The CLI installs fine as a non-superuser.** `stash eql install --eql-version 3 --supabase --direct --database-url …` runs non-interactively as `postgres` on `supabase/postgres` and grants `anon` USAGE on **both** `eql_v3` and `eql_v3_internal`. No `SUPABASE_ADMIN_URL` is needed. (`--supabase` without `--direct`/`--migration` prompts, so pass `--direct`.) +- **`postgres-eql:17-2.3.1` ships EQL v2, not v3.** Every DB variant must install v3 at setup. +- **`./supabase` and `./drizzle` are published stack subpaths** (`npm view @cipherstash/stack exports`); `./eql/v3/drizzle` is not. +- **Moving an adapter out of stack requires promoting internals.** `src/supabase` imports six non-public modules (`@/encryption/helpers`, `@/encryption/operations/base-operation`, `@/eql/v3/columns`, `@/eql/v3/domain-registry`, `@/types`, `@/utils/logger`); `src/eql/v3/drizzle` imports three (`@/types`, `@/schema/match-defaults`, `@/encryption/operations/base-operation`). Note `@/types` is the internal `src/types.ts`, distinct from the published `./types` → `types-public`. + +## Sequencing + +Tests first, so every later refactor lands against a suite that actually proves query correctness. + +| PR | Contents | +|----|----------| +| **PR1** (this plan, Tasks 1–5) | Integration harness + Supabase v3 and Drizzle v3 real-crypto matrices. **No source moves.** | +| **PR2** | Type robustness: import `@cipherstash/eql` per-domain types; stop erasing `Result` and the query-type encoding. | +| **PR3** | Adapter package split: `@cipherstash/stack-drizzle`, `@cipherstash/stack-supabase`. Tests move with the code. | +| **PR4** | v3 JSON support: `types.Json()` + ste_vec, plus its family file in the existing matrix. v3 only. | +| *(independent, any time after PR1)* | Prisma-next live real-crypto suite; best-effort v2 coverage on the same harness. | + +**Why the split is PR3 and not PR1.** It means promoting nine internal stack modules to public API and removing two published subpaths. That is a larger, riskier change than the test work, and it is exactly the refactor that wants an integration suite standing behind it. Doing it first would also churn every test import twice. Tests therefore land in `packages/stack/integration/` and relocate in PR3; because the shared kit is a workspace package from day one, that move is a path change, not a rewrite. + +## File Structure + +``` +packages/test-kit/ # NEW — private, unpublished, no build step + package.json # "private": true; exports "." -> ./src/index.ts + src/ + catalog.ts # MOVED from stack/__tests__/v3-matrix/catalog.ts + families.ts # FamilyName, domainsForFamily() + oracle.ts # plainValue, comparePlain, expectedKeysFor, sortedKeysFor + rows.ts # planTable(), planRows() — data gen + single/bulk split + ops.ts # QueryOpKind, positiveOps(), negativeOps() + adapter.ts # IntegrationAdapter interface + run-family-suite.ts # the driver + env.ts # requireIntegrationEnv(), requireEncryptionClientV3() + install.ts # shells out to `stash eql install --eql-version 3` + index.ts + +vitest.shared.ts # NEW — resolve.alias block, spread into every vitest config + +local/ + docker-compose.postgres.yml # NEW — postgres-eql, no PostgREST + docker-compose.supabase.yml # NEW — supabase/postgres (by digest) + PostgREST + supabase-init.sql # NEW — authenticator LOGIN password + docker-compose.yml # existing; keep or alias + +packages/stack/ + integration/ # NEW — excluded from `pnpm test` + vitest.integration.config.ts + global-setup.ts # requireIntegrationEnv() — fails before docker work + supabase/ + adapter.ts # SupabaseAdapter implements IntegrationAdapter + {integer,smallint,bigint,real-double,numeric,date,timestamp,text,boolean}.integration.test.ts + wire.integration.test.ts # PORTED from __tests__/supabase-v3-pgrest-live.test.ts + drizzle-v3/ + adapter.ts # DrizzleAdapter implements IntegrationAdapter + {integer,smallint,bigint,real-double,numeric,date,timestamp,text,boolean}.integration.test.ts + relational.integration.test.ts # joins, exists/notExists, pagination, and/or/not, bigint + matrix-sql.integration.test.ts # PORTED from __tests__/v3-matrix/matrix-live-pg.test.ts + __tests__/v3-matrix/catalog.ts # becomes a one-line re-export shim + +.github/ + actions/integration-setup/action.yml # NEW — checkout + pnpm + node + install + workflows/integration-drizzle.yml # NEW — db: [postgres] + workflows/integration-supabase.yml # NEW — db: [supabase] +``` + +--- + +### Task 1: Commit this plan + +**Files:** +- Create: `docs/superpowers/plans/2026-07-10-eql-v3-integration-tests.md` + +`docs/` does not ship in the `stash` tarball (only `skills/` does, per `CLAUDE.md:21`), so no changeset is required. + +- [ ] **Step 1: Write the plan doc and commit** + +--- + +### Task 2: `packages/test-kit` — the shared harness + +Move the catalog into a private workspace package so both adapter suites (and, after PR3, both adapter packages) import one source of truth. Consumed as TypeScript source via a vitest alias so every package sees **one module instance** — stack's unit tests do `expect(builder(…)).toBeInstanceOf(spec.ColumnClass)`, which fails across module instances. + +**Files:** +- Create: `packages/test-kit/{package.json,tsconfig.json,src/*.ts}` +- Create: `vitest.shared.ts` +- Modify: `packages/stack/__tests__/v3-matrix/catalog.ts` → one-line re-export shim +- Modify: `pnpm-workspace.yaml`, every `vitest.config.ts` + +**Interfaces:** + +```ts +export type Plain = string | number | bigint | boolean | Date + +export type QueryOpKind = + | 'eq' | 'ne' | 'in' | 'notIn' + | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'notBetween' + | 'contains' | 'order' | 'isNull' | 'isNotNull' + +export type QueryOp = + | { kind: 'eq'|'ne'|'gt'|'gte'|'lt'|'lte'; column: string; value: Plain } + | { kind: 'in'|'notIn'; column: string; values: Plain[]; asRawFilter?: boolean } + | { kind: 'between'|'notBetween'; column: string; lo: Plain; hi: Plain } + | { kind: 'contains'; column: string; needle: string } + | { kind: 'order'; column: string; direction: 'asc'|'desc' } + | { kind: 'isNull'|'isNotNull'; column: string } + +export interface IntegrationAdapter { + readonly name: 'drizzle' | 'supabase' + readonly supportedOps: ReadonlySet // supabase omits 'order' + readonly alwaysRejectedOps: ReadonlySet // supabase: {'order'} + setup(): Promise + teardown(): Promise + createTable(t: TableSpec): Promise + insertSingle(t: TableSpec, row: PlainRow): Promise // MUST hit encryptModel + insertBulk(t: TableSpec, rows: PlainRow[]): Promise // MUST hit bulkEncryptModels + run(t: TableSpec, op: QueryOp): Promise // → matching rowKeys + expectRejected(t: TableSpec, op: QueryOp): Promise +} + +export function runFamilySuite(family: FamilyName, make: () => IntegrationAdapter): void +``` + +Add one field to `DomainSpec`: + +```ts +scope: { covered: true } | { covered: false; reason: string } +``` + +The nine ORE domains (eight numeric/date `_ord_ore` plus `text_ord_ore`) are `{ covered: false, reason: 'ORE is superuser-only; absent on managed Postgres — follow-up' }`. The driver skips them and `console.info`s the reason. Compile-enforcement survives, the exclusion is visible, and the follow-up flips flags rather than adding rows. + +- [ ] **Step 1: Scaffold `packages/test-kit`** (private, no build, `exports: { ".": "./src/index.ts" }`), add to `pnpm-workspace.yaml` +- [ ] **Step 2: Move `catalog.ts`**, repoint its imports from `@/eql/v3`/`@/schema` to `@cipherstash/stack/eql/v3`/`@cipherstash/stack/schema`, add the `scope` field +- [ ] **Step 3: Leave the re-export shim** at `packages/stack/__tests__/v3-matrix/catalog.ts` so the ~10 unit tests importing it need no churn +- [ ] **Step 4: Add `vitest.shared.ts`** aliasing stack subpaths and `@cipherstash/test-kit` to source; spread into each package's vitest config +- [ ] **Step 5: Lift the oracle** (`plainValue`, `comparePlain`, `expectedKeysFor`, `sortedKeysFor`) out of `drizzle-v3/operators-live-pg.test.ts` into `oracle.ts` +- [ ] **Step 6: Write `ops.ts`** — the capability→operation table and `positiveOps`/`negativeOps` +- [ ] **Step 7: Write `rows.ts`** — `planTable()` and `planRows()` (see Task 4 notes on the single/bulk split) +- [ ] **Step 8: Ensure the kit is typechecked in CI** (add to `test:types`), then run `pnpm test` and commit + +--- + +### Task 3: The harness — docker, CLI install, loud env gate + +**Files:** +- Create: `local/docker-compose.postgres.yml`, `local/docker-compose.supabase.yml`, `local/supabase-init.sql` +- Create: `packages/stack/integration/{vitest.integration.config.ts,global-setup.ts}` +- Create: `.github/actions/integration-setup/action.yml` +- Modify: `turbo.json`, `packages/stack/{package.json,vitest.config.ts}` + +**Install via the real CLI.** The harness runs `stash eql install --eql-version 3 --database-url $DATABASE_URL` after `turbo run build --filter stash`. This replaces the hand-rolled `installEqlV3IfNeeded` + `SUPABASE_PERMISSIONS_SQL_V3` apply, and means every integration run exercises the installer customers actually use. `isInstalled` is generation-aware, so repeat local runs are cheap. + +**`supabase-init.sql`.** The `supabase/postgres` image already ships `anon`, `authenticated`, `service_role`, `authenticator`, and a non-superuser `postgres`. This file only guarantees the login PostgREST needs: + +```sql +ALTER ROLE authenticator WITH LOGIN PASSWORD 'authpass' NOINHERIT; +GRANT anon, authenticated, service_role TO authenticator; +``` + +**Do not** reuse `local/postgrest-roles.sql` here: its `IF NOT EXISTS` create-branch skips the password when the role already exists, and PostgREST auth then fails. + +**Loud failure.** `requireIntegrationEnv(requires)` throws, naming exactly what is missing and how to supply it. For CipherStash it accepts **either** the four `CS_*` vars **or** an existing `~/.cipherstash` profile — mirroring `examples/prisma/test/e2e/global-setup.ts:82-90` — then lets protect-ffi's AutoStrategy resolve. It runs in vitest `globalSetup` so it fails before any container work is wasted. + +- [ ] **Step 1: Write the two compose files** (`supabase/postgres` pinned by digest) and `supabase-init.sql`; comment the never-a-pooler constraint +- [ ] **Step 2: Bring both stacks up locally** and confirm `eql_v3.version()` matches the pinned release after `stash eql install --eql-version 3` +- [ ] **Step 3: Confirm the CLI's grants suffice for `anon` without a superuser connection** — the step most likely to surprise us. If they do not, wire a `SUPABASE_ADMIN_URL` for the install only +- [ ] **Step 4: Write `env.ts`** (`requireIntegrationEnv`, `requireEncryptionClientV3`) and `install.ts` +- [ ] **Step 5: Add the integration vitest config + `global-setup.ts`**; add `exclude: ['integration/**']` to the base config; add the `test:integration` script and the `turbo.json` task (`dependsOn: ['^build']`, `cache: false`) +- [ ] **Step 6: Verify** `pnpm test` runs zero integration tests, and that unsetting `PGRST_URL` produces a red failure with an actionable message — **not** a green skip +- [ ] **Step 7: Commit** + +--- + +### Task 4: Supabase v3 real-crypto integration suite + +The headline gap. Nine per-family files, each three lines; all the work lives in `adapter.ts` and the shared driver. + +**Files:** +- Create: `packages/stack/integration/supabase/adapter.ts` + nine `*.integration.test.ts` +- Create: `packages/stack/integration/supabase/wire.integration.test.ts` (ported) +- Create: `.github/workflows/integration-supabase.yml` +- Modify: `packages/stack/__tests__/live-coverage-guard.test.ts` (trim moved assertions) +- Delete: `packages/stack/__tests__/supabase-v3-pgrest-live.test.ts` (after porting) + +**Adapter notes.** Build through the public `encryptedSupabaseV3(client, { schemas, databaseUrl })` so the shipped construction path — introspection, declared-schema merge, real `Encryption({ eqlVersion: 3 })` — is what runs. `supportedOps` = all except `order`; `alwaysRejectedOps = {'order'}` (PostgREST cannot emit `ORDER BY eql_v3.ord_term(col)`, and the adapter refuses by design). Synthesize what the builder lacks: `between` → `.gte(lo).lte(hi)`; `notBetween` → `.or('c.lt.lo,c.gt.hi')`; `notIn` → `.or('c.not.in.(…)')`. + +**Single vs bulk.** `planRows` splits the value rows into disjoint halves: single = `{A, C}` via `.insert(obj)` (→ `encryptModel`), bulk = `{B, D}` via `.insert(array)` (→ `bulkEncryptModels`). The per-domain `eq`-over-every-row loop necessarily matches rows from both halves; on top of that, one explicit crossover assertion per family (a match-all predicate must return a superset of `{aSingle, aBulk}`) makes "the bulk path mangled a row" a red test rather than a coincidence. + +**Rejection matrix, derived.** + +```ts +const OPS_BY_CAPABILITY = { + equality: ['eq','ne','in','notIn'], + orderAndRange: ['gt','gte','lt','lte','between','notBetween','order'], + freeTextSearch: ['contains'], +} +// isNull/isNotNull are structural, never capability-gated. +``` + +Flipping a capability flag must flip a positive test into a negative one. Verify this by perturbing `text_match` to `equality: true` and watching its `eq` test change from a passing rejection to a failing query. + +**Why the wire suite survives.** `supabase-v3-pgrest-live.test.ts` is *not* superseded. It uniquely proves the `23514` rejection of a narrowed `encryptQuery`-shaped term (a shape the adapter cannot itself produce, so it must be hand-built), dense PostgREST parse edges, plaintext-passthrough containment on array/jsonb columns, and the grants as `anon`. The stub is the point: **no CipherStash credentials**, so it runs wherever the DB-only jobs run. Document the deliberate overlap at the top of the file, or someone will "clean up" one of the two. + +**The two PR #535 fixes map here.** The raw `.filter(col,'in',[…])` element-wise encryption fix is covered by running every eq-capable domain through *both* `.in()` and the raw-filter path (`asRawFilter: true`) against the same oracle with real ciphertext. The PostgREST select-alias `Date` reconstruction fix is covered in the `date` and `timestamp` family files by asserting `select('row_key, ts:')` yields a real `Date`; this needs a small `{ alias }` option on `SupabaseAdapter.run`, kept off the shared interface (Drizzle has no such concept). + +**`live-coverage-guard.test.ts` must be trimmed in this same commit.** It asserts `LIVE_SUPABASE_PGREST_ENABLED` is true in CI; once these suites leave `tests.yml`, that job stops setting `PGRST_URL` and the guard goes red. Delete only the assertions whose suites moved; ~15 non-adapter live suites still use `LIVE_*`. + +- [ ] **Step 1: Write `SupabaseAdapter`** against `encryptedSupabaseV3` +- [ ] **Step 2: Write one family file** (`integer`) and get it green against the supabase compose stack +- [ ] **Step 3: Verify the suite catches the #535 bugs** — revert only `packages/stack/src/supabase/`, confirm the raw-filter `in` and alias-`Date` tests go red, restore +- [ ] **Step 4: Verify the rejection matrix is derived** — perturb one capability flag, confirm the corresponding test flips, revert +- [ ] **Step 5: Fill in the remaining eight family files** +- [ ] **Step 6: Port `supabase-v3-pgrest-live.test.ts`** → `wire.integration.test.ts`, de-gated, with the overlap documented +- [ ] **Step 7: Trim `live-coverage-guard.test.ts`**; add `integration-supabase.yml` +- [ ] **Step 8: Run the full suite against `supabase/postgres`, then commit** + +--- + +### Task 5: Port the Drizzle v3 suite onto the harness + +**Files:** +- Create: `packages/stack/integration/drizzle-v3/adapter.ts` + nine `*.integration.test.ts` +- Create: `packages/stack/integration/drizzle-v3/relational.integration.test.ts` +- Create: `packages/stack/integration/matrix-sql.integration.test.ts` (ported) +- Create: `.github/workflows/integration-drizzle.yml` +- Delete: `packages/stack/__tests__/drizzle-v3/operators-live-pg.test.ts`, `__tests__/v3-matrix/matrix-live-pg.test.ts` (after porting) + +The per-domain logic becomes `DrizzleAdapter` + `runFamilySuite`. The bespoke, non-family-shaped tests move to `relational.integration.test.ts`: plain-table joins, `exists`/`notExists` correlated subqueries, `limit`/`offset` pagination, `and`/`or`/`not` disjoint-predicate proofs, the statically-typed bigint round-trip, and the >4-value bulk in-list. Text-specific edge guards (short-needle rejection, astral `👍`, NFD normalization) are richer than the capability matrix and stay as bespoke assertions in the text family file. + +`supportedOps` = all kinds; `alwaysRejectedOps` = ∅. Ordering uses `ORDER BY eql_v3.ord_term(col)`, safe because `_ord` is OPE. + +`matrix-live-pg.test.ts` is **kept, not deleted for redundancy** — it tests the `eql_v3.*` SQL operators directly, independent of any ORM (`contained_by`, empty-string domain CHECK accept/reject, storage round-trip). It moves to `matrix-sql.integration.test.ts` and is de-gated. + +This suite currently seeds only via `bulkEncryptModels`; the harness's single/bulk split closes that gap for free. + +- [ ] **Step 1: Write `DrizzleAdapter`** +- [ ] **Step 2: Port one family file**, confirm parity with the assertions it replaces +- [ ] **Step 3: Fill in the remaining eight** +- [ ] **Step 4: Move the bespoke tests** into `relational.integration.test.ts`; confirm nothing is lost by diffing the `it(` titles against the original +- [ ] **Step 5: Port `matrix-live-pg.test.ts`** → `matrix-sql.integration.test.ts`, de-gated +- [ ] **Step 6: Delete the originals**; add `integration-drizzle.yml` +- [ ] **Step 7: Run both workflows' suites locally, then commit** + +--- + +## CI + +One workflow per adapter, not an adapter×db matrix: the cross-product is meaningless (each adapter is fixed to one DB variant), and `paths:` filters are per-workflow — a shared workflow would pull the ~2 GB `supabase/postgres` image on Drizzle-only PRs. Keep `strategy.matrix.db` as a one-element list so the shape is ready if that changes. + +Both workflows: fork-PR gated via `if: github.event.pull_request.head.repo.full_name == github.repository` (a clean skip, as `prisma-next-e2e.yml` does); keep `require-cs-secrets` as a **fast pre-flight** before the docker pull; pass secrets via job-level `env:` rather than writing `.env` files (`dotenv/config` does not override an already-set `process.env`, so job env wins and ~5 `.env`-writing steps disappear). + +## Verification + +Observed, not assumed. + +1. **Harness boots.** `docker compose -f local/docker-compose.supabase.yml up -d --wait`, `stash eql install --eql-version 3`, then `eql_v3.version()` matches the pinned release and `curl -s localhost:3000/ | jq '.paths|keys'` lists the test table. +2. **Loud failure works.** Run with `PGRST_URL` unset → fails with the actionable message; does **not** skip green. +3. **Profile fallback works.** Unset all four `CS_*` with `~/.cipherstash` present → suite runs. Move the profile aside → suite fails loudly. +4. **The suite catches the bugs it exists for.** Revert only `packages/stack/src/supabase/` and re-run: the raw-filter `in` tests and the alias-`Date` tests must go red. (This is how the current PR #535 fixes were validated — 4 of 6 live tests failed against unfixed source.) +5. **The rejection matrix is derived, not decorative.** Give `text_match` `equality: true` → its `eq` test must turn from a passing rejection into a failing query. Revert. +6. **Ordering works on the managed-Postgres variant.** `asc`/`desc` on an `_ord` (OPE) column returns true plaintext order against `supabase/postgres`. +7. **CI shape.** `pnpm test` at the repo root runs zero integration tests; a fork PR shows the integration jobs as *skipped*, not failed. + +## Follow-ups queued after PR1 + +Both are consequences of PR1, and both are about the same thing: a skipped test reads exactly like a passing one. + +**Remove the `LIVE_*` gates and the 16 unit-suite skips.** `__tests__/helpers/live-gate.ts` still turns `LIVE_CIPHERSTASH_ENABLED`, `LIVE_EQL_V3_PG_ENABLED`, `LIVE_PG_ENABLED` and `LIVE_LOCK_CONTEXT_ENABLED` into `describe.skip`. `live-coverage-guard.test.ts` exists *only* because a false gate is a silent whole-suite skip on a green job. Move those suites into the integration jobs — which throw rather than skip — then delete both files, and extend `no-skips-reporter.ts` to the unit config once it is clean. + +**Port the remaining live suites onto the shared harness.** Still bypassing it: `drizzle-v3/operators-null-live-pg`, `drizzle-v3/operators-lock-context-live-pg`, `v3-matrix/matrix-live*`, `schema-v3-pg`, `supabase-v3-grants-pg`, `supabase-v3-introspect-pg`. Each gets the shared env gate and no skips. This is also where the **superuser-only ORE suite** lands — the one the catalog's `deferred` field points at, covering the nine `_ord_ore` domains that cannot hold data on managed Postgres. + +## PR2 — type robustness (outline) + +Import the canonical per-domain types from `@cipherstash/eql` and thread them through. Stop typing `OperandEncryptionClient.encrypt`/`bulkEncrypt` as returning `unknown` (`eql/v3/drizzle/operators.ts:51,55`); stop collapsing `Result<…>` to `{ data?: unknown }` (`:94-101`); stop returning `Promise` from `encryptOperands` and from `encryptCollectedTerms`/`bulkEncryptGroup`/`encryptGroupPerTerm` (`supabase/query-builder-v3.ts:393,433,463`). Where a `JSON.stringify` is genuinely required at the SQL boundary, it should serialize a *typed* envelope, not an `unknown`. The PR1 suite is what makes this safe to attempt. + +## PR3 — adapter package split (outline) + +``` +@cipherstash/stack (core) +@cipherstash/stack-drizzle deps: stack ← stack/src/drizzle (v2) + src/eql/v3/drizzle +@cipherstash/stack-supabase deps: stack ← stack/src/supabase +@cipherstash/prisma-next deps: stack (existing precedent) + +@cipherstash/drizzle@3.x peer: @cipherstash/protect@12 — untouched, maintenance +``` + +stack does **not** re-export the new packages, so no build cycle arises — the shape `@cipherstash/prisma-next` already proves in production. `@cipherstash/protect` is succeeded by stack, so `@cipherstash/drizzle@3.x` and `packages/protect` enter maintenance and the two forked Drizzle implementations stop diverging by attrition. Once protect sunsets, `stack-drizzle` can reclaim the `@cipherstash/drizzle` name in a major — do not attempt that now. + +Work: promote nine internal stack modules to public API; drop `./drizzle`, `./supabase`, `./eql/v3/drizzle` from `exports`/`typesVersions`/`tsup.config.ts` (stack is 0.19.0, so a minor bump carries the break under 0.x semver); update 15 doc/skill references; move the integration suites into the new packages; follow the `fta-v3.yml` complexity gate to the moved code or it silently loses its gate. + +## PR4 — v3 JSON (outline) + +Add a `'json'` `cast_as` kind and a `types.Json()` column to the core v3 schema, backed by `public.eql_v3_json` / `public.eql_v3_jsonb_entry` and the bundle's 56 ste_vec functions. Surface the query operations (`jsonb_path_exists`, selectors, containment) on both adapters. `eql/v3/drizzle/codec.ts:38` already decodes SteVec documents, so the read path is partly there. Add a `json` family file to the existing matrix. v3 only — v2 `searchableJson` is not a priority. + +## Risks + +- **Split blast radius (PR3).** Nine internal modules become public API, two published subpaths disappear, 15 doc references change. If any module is too internal to expose, relocate the shared piece to `packages/schema` or the test kit — a design call to make before coding, not during. +- **Two Drizzle implementations stay forked** until protect sunsets. Anyone fixing a bug in one should check the other; worth a comment atop both operator files. +- **`supabase/postgres` is ~2 GB.** Pin by digest, lean on the Blacksmith layer cache, rely on path-filtered triggering. If CI minutes bite, `postgres-eql` + `postgrest-roles.sql` reproduces the role surface at ~10% of the size — revisit then, not now. +- **CLI-based install adds a build step** (`turbo run build --filter stash`) to every integration job. Worth it: it is the only thing that tests the installer. +- **Source-aliasing stack's public surface in vitest** is the price of one shared catalog plus a working `instanceof`. Centralize it in `vitest.shared.ts` rather than copy-pasting. +- **Deliberate overlap** between the stub wire suite and the real-crypto matrix must be documented, or it will be "cleaned up". diff --git a/docs/superpowers/specs/2026-07-02-stryker-v3-ci-gate-design.md b/docs/superpowers/specs/2026-07-02-stryker-v3-ci-gate-design.md index a149cdad7..82eb2f412 100644 --- a/docs/superpowers/specs/2026-07-02-stryker-v3-ci-gate-design.md +++ b/docs/superpowers/specs/2026-07-02-stryker-v3-ci-gate-design.md @@ -147,8 +147,10 @@ Implementation therefore includes a **baseline step**: locally. 2. Record the reported mutation score for `eql/v3`. 3. Set `thresholds.break` just **below** the measured score (a small buffer, the - way FTA sets `--score-cap 72` against a current 71.08). This ensures the - current state passes while any regression that lowers the score fails the gate. + way FTA sets `--score-cap 69` against a current worst-file score of 68.00 — + re-baselined from the pre-split monolith's 71.08/72 after `eql/v3` was split + into per-file modules). This ensures the current state passes while any + regression that lowers the score fails the gate. 4. Set `high`/`low` to reasonable display bands (do not affect pass/fail). If the measured baseline is very low (tests are weak), surface that to the user diff --git a/docs/superpowers/specs/2026-07-06-eql-v3-drizzle-concrete-types-design.md b/docs/superpowers/specs/2026-07-06-eql-v3-drizzle-concrete-types-design.md new file mode 100644 index 000000000..5995194df --- /dev/null +++ b/docs/superpowers/specs/2026-07-06-eql-v3-drizzle-concrete-types-design.md @@ -0,0 +1,286 @@ +# EQL v3 Drizzle support — concrete-type authoring — design + +Status: proposed +Date: 2026-07-06 +Branch: `feat/eql-v3-text-search-schema` + +## 1. Goal + +Add EQL v3 support to the Drizzle integration inside `@cipherstash/stack`, mirroring +the existing v2 Drizzle integration (`@cipherstash/stack/drizzle`) but re-shaped +around the v3 **concrete-type** model. + +The defining change of v3: **the concrete type defines the search capabilities.** +A column declared `eql_v3.int4_eq` supports equality; `eql_v3.int4_ord` supports +order/range (and equality via ORE); `eql_v3.text_search` supports equality, order, +and free-text match. There is no separate `.equality()` / `.orderAndRange()` / +`.freeTextSearch()` index configuration as in v2 — everything the adapter needs +(SQL column domain, `cast_as`, and which operators are legal) is **derived from the +concrete type**, which already carries that metadata in +`@cipherstash/stack/eql/v3`. + +Success = a developer can declare a Drizzle `pgTable` with encrypted v3 columns, +feed the same schema to `EncryptionV3`, and run equality / range / free-text / +ordering queries through Drizzle using capability-checked operators that emit the +correct `eql_v3` term-function SQL. + +## 2. Background: why v3 is different from v2 + +Confirmed against this branch's SQL bundle +(`packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql`) and the live +pg tests (`packages/stack/__tests__/schema-v3-pg.test.ts`). + +**Column type.** v2 uses a single composite type `eql_v2_encrypted` for every +encrypted column. v3 uses **one `CREATE DOMAIN … AS jsonb` per concrete type** — +`eql_v3.int4_ord`, `eql_v3.text_eq`, `eql_v3.text_search`, `eql_v3.bool`, … There is +no single catch-all `eql_v3_encrypted`. + +**Wire form.** v2 writes a composite literal `("…")`. v3 domains are plain jsonb, so +the value is inserted as plain JSON cast to the domain (`$1::eql_v3.int4_ord`). + +**Query form.** v2 compares encrypted payloads directly (native `=` on +`eql_v2_encrypted`, or `eql_v2.gt/lt/like/order_by(...)` convenience functions). v3 +has **no convenience operators**; it compares **extracted index terms** on both +sides: + +| Capability | v3 SQL | +| --- | --- | +| equality (HMAC) | `eql_v3.eq_term(col) = eql_v3.hmac_256($::jsonb)` | +| equality (ORE, numeric/date order domains) | `eql_v3.ord_term(col) = eql_v3.ore_block_256($::jsonb)` | +| order/range | `eql_v3.ord_term(col) />= eql_v3.ore_block_256($::jsonb)` | +| free-text match | `eql_v3.match_term(col) @> eql_v3.bloom_filter($::jsonb)` | +| order by | `ORDER BY eql_v3.ord_term(col)` | + +The column-side extractor (`eq_term`/`ord_term`/`match_term`) takes the column +domain (its stored value has ciphertext `c`, so it passes the domain CHECK). The +search-side constructor (`hmac_256`/`ore_block_256`/`bloom_filter`) pulls the index +field straight out of the query-term jsonb with no domain coercion — this is why a +query term (which has no ciphertext) must be cast to `::jsonb`, never to the domain. + +**Concrete types already exist.** `@cipherstash/stack/eql/v3` ships the full +concrete-type system (`packages/stack/src/eql/v3/{columns,types,table,index}.ts`): +- `types.(name)` factories for all 35 shipped domains. +- Each `EncryptedV3Column` carries `getEqlType()` (`eql_v3.int4_ord`), `castAs` + (`'string' | 'number' | 'boolean' | 'date'`), `getQueryCapabilities()` + (`{ equality, orderAndRange, freeTextSearch }`), and `build()` → + `{ cast_as, indexes: { unique?, ore?, match? } }`. +- `encryptedTable(name, columns)` builds the schema `EncryptionV3` consumes. +- `EncryptionV3(...).encryptQuery(value, { table, column, queryType })` produces the + query term; the FFI's `resolveIndexType` picks the index (including equality-via-ORE + for numeric/date order domains). + +This adapter **reuses** that system verbatim — it never re-declares domain or +capability data. + +## 3. Scope + +### In scope +- A new Drizzle v3 module in `@cipherstash/stack`, exported at + `@cipherstash/stack/eql/v3/drizzle` (nested under the existing `eql/v3` namespace). +- A Drizzle-native `types` namespace with the **identical PascalCase factory names** + as `@cipherstash/stack/eql/v3` (`types.TextSearch`, `types.Int4Ord`, `types.Bool`, + … all 35 shipped domains), each returning a Drizzle `customType` column. +- Plain-jsonb codec (`toDriver` / `fromDriver`). +- Schema extraction: Drizzle table → v3 `encryptedTable` for `EncryptionV3`. +- `createEncryptionOperatorsV3(client)` — capability-checked async operators: + `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `between`, `notBetween`, `like`, `ilike`, + `notIlike`, `inArray`, `notInArray`, `asc`, `desc`, `and`, `or`, plus the + pass-through non-encrypting operators (`isNull`, `isNotNull`, `not`, `exists`, + `notExists`). +- Detection: recover the concrete builder from a processed Drizzle column. +- A `.changeset/` entry (minor `@cipherstash/stack`). + +### Out of scope (explicit gaps, not silent omissions) +- **JSON / `ste_vec`** operators (`jsonbPathQueryFirst`, `jsonbGet`, + `jsonbPathExists`). No v3 JSON column builder ships yet (`eql_v3.json` / + `ste_vec` have no `types.*` factory), so these are simply absent from the v3 + operator surface — there is no v3 column they could target. Deferred until a v3 + JSON builder exists. +- **int8 / bigint** domains — intentionally absent from `eql/v3` pending lossless + FFI round-tripping. This adapter mirrors that: no int8 factory. +- **`like`/`ilike` pattern semantics.** v3's only text-match SQL is bloom-filter + containment (`match_term @> bloom_filter`), which is **token/substring matching, + not SQL `LIKE` patterns**. `like`/`ilike`/`notIlike` all map to containment + (`notIlike` = `NOT (…)`); wildcards in the argument are not interpreted. Documented + on each operator. +- **No changes to the v2 Drizzle module** (`@cipherstash/stack/drizzle`) or the + standalone `@cipherstash/drizzle` package. Zero v2 regression surface. +- **No dialect-seam refactor of the v2 `operators.ts`.** The v3 operators are a + self-contained module; the SQL-dialect seam (below) lives only inside v3. + +## 4. Architecture & location + +``` +packages/stack/src/eql/v3/drizzle/ + index.ts // barrel: types, createEncryptionOperatorsV3, extractEncryptionSchemaV3, errors + types.ts // Drizzle `types` namespace (PascalCase factories → customType columns) + column.ts // customType wrapper + detection + config stash + codec.ts // plain-jsonb toDriver / fromDriver + sql-dialect.ts // v3 term-function SQL emission (local seam) + operators.ts // createEncryptionOperatorsV3 + schema-extraction.ts // Drizzle table → eql/v3 encryptedTable +``` + +Package wiring: add `"./eql/v3/drizzle"` to `packages/stack/package.json` `exports` +and to the tsup entry list, following the existing `./eql/v3` and `./drizzle` +entries. + +The v3 module depends inward on `@/eql/v3` (concrete types + `encryptedTable`) and +the base `EncryptionClient` (`@/encryption`) — the same client the v2 Drizzle +operators use. It does **not** depend on the v2 Drizzle module. + +## 5. Components + +### 5.1 `types` namespace + column wrapper (`types.ts`, `column.ts`, `codec.ts`) + +`types.TextSearch(name)` (and the 34 siblings) returns a Drizzle column built via +`customType`. Each factory: + +1. Constructs the corresponding `eql/v3` builder — `v3.types.TextSearch(name)` — the + **single source of truth** for domain / `cast_as` / capabilities. No metadata is + re-declared here; this file is a name→delegate map. +2. Builds a `customType<{ data: Plaintext; driverData: string | null }>` whose + `dataType()` returns `builder.getEqlType()` (e.g. `eql_v3.int4_ord`), and whose + `toDriver`/`fromDriver` are the plain-jsonb codec. +3. Stashes the `eql/v3` builder on the column (`_eqlv3Column`) **and** in a + module-global map keyed by column name — mirroring v2's dual registration — so + detection and schema-extraction can recover it after `pgTable` strips custom + props. + +The decrypted TypeScript type is `PlaintextForColumn` (string / +number / boolean / Date), so `users.age` decrypts to `number`, `users.createdAt` to +`Date`, etc. + +**Codec** (`codec.ts`), proven by the `eql-v3-drizzle-adapter` branch: +- `toDriver`: `null`/`undefined` → SQL `NULL` (JS `null`). The v3 domains + `CHECK jsonb_typeof(VALUE) = 'object'`, so a JSONB `null` literal would fail the + domain; SQL NULL is accepted. Otherwise `JSON.stringify(value)`. +- `fromDriver`: pass `null` through; return already-parsed objects as-is (the + postgres driver may hand back a parsed jsonb object); else `JSON.parse`. + +**Detection** (`column.ts`): `isEqlV3Column(column)` / `getEqlV3Column(name, column)` +check `_eqlv3Column`, falling back to the name-keyed map, and validate the +`dataType()` string is one of the known `eql_v3.*` domains (source: iterate the +`eql/v3` `types` factories once at module load to build the domain set — no +hand-maintained string list). + +### 5.2 SQL dialect (`sql-dialect.ts`) + +A small object that emits the v3 term-function SQL, keyed off which index the column +exposes. Gating and dialect both read `builder.build().indexes` — the authoritative +index set: + +- `indexes.unique` present → equality via `eql_v3.eq_term(col) = eql_v3.hmac_256($::jsonb)`. +- `indexes.ore` present → order/range via `eql_v3.ord_term(col) eql_v3.ore_block_256($::jsonb)`; + order-by via `eql_v3.ord_term(col)`; **and** equality via ORE when `unique` is + absent (`eql_v3.ord_term(col) = eql_v3.ore_block_256($::jsonb)`). +- `indexes.match` present → free-text via `eql_v3.match_term(col) @> eql_v3.bloom_filter($::jsonb)`. + +Query terms are bound params already wrapped with `bindIfParam` by the caller, then +cast `::jsonb` inside the constructor call. Constructor names are pinned to this +branch's bundle: `hmac_256`, `ore_block_256`, `bloom_filter` (note: **not** the +`ore_block_u64_8_256` spelling from the older adapter branch — that predates this +bundle). + +### 5.3 Operators (`operators.ts`) + +`createEncryptionOperatorsV3(client: EncryptionClient)` returns the async-operator +object, same ergonomics as v2 (`await ops.eq(users.email, 'x')`, `ops.and(...)` / +`ops.or(...)` batch encryption, `ops.asc(...)` / `ops.desc(...)`, +`ops.inArray(...)`). Per operator: + +| Operator | Requires index | `queryType` sent to `encryptQuery` | Emitted SQL | +| --- | --- | --- | --- | +| `eq` / `ne` | `unique` or `ore` | `equality` | `unique` → `eq_term = hmac_256`; else `ord_term =/<> ore_block_256` | +| `gt`/`gte`/`lt`/`lte` | `ore` | `orderAndRange` | `ord_term />= ore_block_256` | +| `between` / `notBetween` | `ore` | `orderAndRange` | `ord_term >= ore_block_256($min) AND ord_term <= ore_block_256($max)`, NOT-wrapped for `notBetween` | +| `like`/`ilike`/`notIlike` | `match` | `freeTextSearch` | `match_term @> bloom_filter`, NOT-wrapped for `notIlike` | +| `inArray`/`notInArray` | `unique` or `ore` | `equality` | OR of `eq` terms / AND of `ne` terms | +| `asc` / `desc` | `ore` | — | `ORDER BY eql_v3.ord_term(col)` | +| `isNull`/`isNotNull`/`not`/`exists`/`notExists` | — | — | pass-through Drizzle operators | + +Term encryption reuses the column's recovered `eql/v3` builder + its owning +`encryptedTable` (rebuilt via schema-extraction and cached per table, exactly as v2 +caches the ProtectTable): `client.encryptQuery(value, { table, column, queryType })`. + +**Error handling — no silent fallback.** In v2, an operator on a non-encrypted +column falls through to the plain Drizzle operator. In v3 that is impossible: a v3 +domain column has no plaintext form, and using the wrong operator emits SQL the +domain CHECK rejects at runtime. So the operators **throw `EncryptionOperatorError`** +(reusing the v2 error class name) when a column lacks the required index — e.g. +`ops.gt` on a `types.TextEq` column (equality-only, no `ore`), or `ops.ilike` on a +column without `match`. The message names the column, operator, and the missing +capability. A non-v3 column passed to a v3 operator also throws (it can't be a v3 +domain), rather than silently degrading. + +### 5.4 Schema extraction (`schema-extraction.ts`) + +`extractEncryptionSchemaV3(drizzleTable)` iterates the Drizzle columns, recovers each +stashed `eql/v3` builder via detection, and returns +`encryptedTable(tableName, { : builder, … })` — ready for +`EncryptionV3({ schemas: [users] })`. Throws if the table has no v3 columns (mirrors +v2's `extractEncryptionSchema`). Operators call this internally to resolve the +`encryptedTable` for a column's parent table, caching per table name. + +## 6. Data flow (per query) + +``` +types.Int4Ord('age') // authoring + → customType dataType() = 'eql_v3.int4_ord', stash eql/v3 builder +pgTable('users', { age }) // Drizzle table + +extractEncryptionSchemaV3(users) // → encryptedTable('users', { age: }) +EncryptionV3({ schemas: [users-schema] }) // typed client + +await ops.gte(users.age, 30) + → recover builder (ore index present ✓) + → client.encryptQuery(30, { table, column, queryType: 'orderAndRange' }) // term + → sql`eql_v3.ord_term(${users.age}) >= eql_v3.ore_block_256(${term}::jsonb)` +``` + +## 7. Testing + +Mirror `packages/drizzle/__tests__` structure, plus the v3 live-pg pattern from +`packages/stack/__tests__/schema-v3-pg.test.ts`. Location: +`packages/stack/__tests__/drizzle-v3/` (or alongside the existing +`packages/stack/__tests__/drizzle-*.test.ts` files, matching whatever the v2 drizzle +tests in stack already use). + +**Unit (no DB):** +- `types.*` produce the correct `dataType()` domain string for a representative set + across every scalar family and capability tier. +- Codec round-trip (object ⇄ jsonb string; null ⇄ SQL NULL). +- `extractEncryptionSchemaV3` rebuilds the expected `encryptedTable` (`build()` + output equals the directly-authored `eql/v3` table's). +- Operator SQL emission via a mock client + `PgDialect`: assert exact + `eql_v3.eq_term/ord_term/match_term` + `hmac_256/ore_block_256/bloom_filter` + strings and the equality-via-ORE branch on an order-only numeric column. +- Gating errors: `gt` on equality-only, `ilike` on non-match column, and a non-v3 + column passed into a v3 operator. + +**Live pg** (gated by `LIVE_EQL_V3_PG_ENABLED`, install via `installEqlV3IfNeeded`): +- One `pgTable` with a representative column per tier: `types.TextSearch('email')`, + `types.Int4Ord('age')`, `types.TextEq('nickname')`, `types.Bool('active')`. +- Seed with `EncryptionV3(...).bulkEncryptModels` (or raw insert with + `$::eql_v3.` casts), then real Drizzle `select().where(await ops.eq(...))`, + `ops.gte(...)`, `ops.between(...)`, `ops.ilike(...)`, `orderBy(ops.asc(...))`; + decrypt; assert the selected rows. Use `test_run_id` isolation like the v2 suite. + +## 8. Open implementation details (resolved during build, not blocking) + +- Exact test directory name / whether to gate live tests behind the same env var the + stack v3 pg tests use (`LIVE_EQL_V3_PG_ENABLED`) — adopt the existing helper. +- Whether `between` on a text order domain (which has both `unique` and `ore`) needs + any special handling — it uses `ore`, same as numeric; verify against a live row. +- Confirm the postgres driver path Drizzle uses binds `$::jsonb` correctly for the + term param (the pg tests use `sql.json(...)`; Drizzle's `bindIfParam` + `::jsonb` + cast is the equivalent — assert in a live round-trip). + +## 9. Non-goals / follow-ups (tracked, not in this milestone) + +- v3 JSON / `ste_vec` operators once a v3 JSON column builder ships. +- int8 / bigint once the FFI round-trips losslessly. +- Mirroring into the standalone `@cipherstash/drizzle` package (only if it must ship + v3 independently of `@cipherstash/stack`). +- drizzle-kit migration generation for v3 domains (the v2 `generate-eql-migration` + path emits `eql_v2_encrypted`; a v3 equivalent is a separate effort). diff --git a/docs/superpowers/specs/2026-07-09-supabase-v3-introspection-design.md b/docs/superpowers/specs/2026-07-09-supabase-v3-introspection-design.md new file mode 100644 index 000000000..9a6f04c84 --- /dev/null +++ b/docs/superpowers/specs/2026-07-09-supabase-v3-introspection-design.md @@ -0,0 +1,388 @@ +# Supabase v3 adapter: schema introspection at connect time + +**Status:** design +**Date:** 2026-07-09 +**Package:** `@cipherstash/stack/supabase` + +## Summary + +`encryptedSupabaseV3` becomes a connect-time-async factory that reads the +database schema, detects EQL v3 columns by their Postgres domain, and derives +each column's encryption config from its domain. Callers stop passing a schema +to `from()`. + +```ts +const supabase = await encryptedSupabaseV3(supabaseUrl, supabaseKey) + +await supabase.from('users').insert({ email: 'alice@example.com' }) + +const { data } = await supabase + .from('users') + .select() + .eq('email', 'alice@example.com') +``` + +Declaring schemas remains available, and adds compile-time types plus +startup verification of the database against the declaration. + +## Motivation + +Today both `encryptedSupabase` and `encryptedSupabaseV3` require the caller to +build an `EncryptionClient`, build a Supabase client, and pass a schema object +to every `from()` call. For v3 the schema object is largely redundant: a v3 +column's Postgres domain (`public.text_search`, `public.integer_ord`, …) *is* +its encryption config. The database already holds every fact the adapter needs. + +## Background: how the v2 adapter works + +`encryptedSupabase({ encryptionClient, supabaseClient })` returns an object with +one member, `from(tableName, schema)`, constructing an +`EncryptedQueryBuilderImpl`. That builder mirrors supabase-js's chainable +surface, but every method is a *recorder* — it pushes onto `this.filters` / +`this.transforms` / `this.mutation` and returns `this`. Nothing executes. + +The builder is `PromiseLike`. Awaiting it calls `execute()` +(`query-builder.ts:343`), which: + +1. Encrypts mutation data (`encryptModel` / `bulkEncryptModels`), then wraps + each value as `{ data: … }` for the `eql_v2_encrypted` composite. +2. Builds the select string, appending `::jsonb` to encrypted columns. + `select('*')` throws — there is no column list to cast. +3. Walks the filter buckets, collects encryptable terms into a flat `terms[]` + with a parallel `termMap[]` recording provenance, and batch-encrypts them in + one `encryptQuery()` call. +4. Replays the recorded chain onto the real Supabase builder, substituting + encrypted values where a term existed. +5. Decrypts result rows. + +The schema is consulted for exactly three things: the set of encrypted column +**names**, the column **builder** for each name (which carries the index +config), and the **table** object as encryption context. + +`EncryptedQueryBuilderV3Impl` overrides protected seams on this machinery — +full-envelope filter operands, raw jsonb mutation payloads, `like` → `cs`, +property↔DB name resolution, `Date` reconstruction from `cast_as`. The +recording and replay machinery is shared. + +Only the three schema lookups change under this design. The query mechanism +does not. + +## Design + +### 1. Load the type + +Every v3 domain is `CREATE DOMAIN public. AS jsonb`. For a domain column, +`information_schema.columns` populates `domain_schema` and `domain_name`; both +`data_type` and `udt_name` report the *base* type. + +Measured against Postgres 17 (spike, 2026-07-09): + +| column | `data_type` | `udt_name` | `domain_schema` | `domain_name` | +|---|---|---|---|---| +| `id serial` | integer | int4 | — | — | +| `email spike.text_search` | jsonb | jsonb | spike | text_search | +| `note text` | text | text | — | — | +| `meta jsonb` | jsonb | jsonb | — | — | + +Three consequences: + +- **`domain_name` is unqualified**, with `domain_schema` returned separately. +- **`udt_name` is `jsonb`**, so the v2 detection + (`udt_name === 'eql_v2_encrypted'`, + `packages/cli/src/commands/init/lib/introspect.ts:88`) cannot be adapted by + swapping the compared string — it would compare against `jsonb` forever. + `eql_v2_encrypted` has `typtype = 'c'` (composite), which is why it surfaces + in `udt_name`; domains surface in `domain_name`. +- **A plain `jsonb` column has `domain_name` NULL**, so encrypted and + unencrypted jsonb columns are cleanly distinguishable. A domain carrying a + `CHECK` constraint — as every EQL domain does — reports identically to one + without. + +```sql +SELECT c.table_name, c.column_name, c.domain_name +FROM information_schema.columns c +JOIN information_schema.tables t + ON t.table_name = c.table_name AND t.table_schema = c.table_schema +WHERE c.table_schema = 'public' + AND t.table_type = 'BASE TABLE' +ORDER BY c.table_name, c.ordinal_position +``` + +Plaintext columns are retained, not filtered out. This buys three things: + +- `from('unknown_table')` throws rather than silently passing through. +- A table with zero encrypted columns is a *known* passthrough. +- `select('*')` becomes expandable — emit the full column list with `::jsonb` on + the encrypted ones — so the current `select('*')` throw is removed. + +A `domain_name` absent from the registry (a user's own domain, or a newer EQL +release) is treated as plaintext. Not an error. + +### 2. Use the type + +`packages/stack/src/eql/v3/columns.ts` defines 47 domain constants, each +`{ eqlType, castAs, capabilities }`. `public.integer_ord` is +`castAs: 'number'`, order-and-range. That *is* the encryption config. + +Add a `DOMAIN_REGISTRY: Record AnyEncryptedV3Column>` +keyed by unqualified domain name, whose values are the **existing `types` +factories** (`eql/v3/types.ts`) rather than direct `new EncryptedXColumn(...)` +calls. The factories pass the literal domain constants +(`Integer: (name) => new EncryptedIntegerColumn(name, INTEGER)`), and that +literal is what keeps the domains nominally distinct. Constructing the classes +directly would create a second source of truth for exactly the thing the class +comments warn about drifting. `types.TextSearch` has a different arity — +`(name) => new EncryptedTextSearchColumn(name)`, no constant — so the registry +maps values, not a mechanical transform. + +**Key normalization.** `eqlType` is qualified (`'public.text_search'`), while +`information_schema` returns `domain_schema = 'public'` and +`domain_name = 'text_search'` as separate columns. The registry is keyed on the +unqualified name; the exhaustiveness test must strip the `public.` prefix from +each `eqlType` before comparing, or it will pass while matching nothing. + +A test asserts every `eqlType` in `columns.ts` has a registry entry, and that +each entry round-trips: `registry[strip(eqlType)]('c').getEqlType() === eqlType`. + +Introspected rows group by table into synthesized `EncryptedTable` instances, +which feed `EncryptionV3({ schemas })`. + +Because introspection yields DB column names directly, the JS property name +equals the DB column name. `propToDb` is the identity, and the `prop:db::jsonb` +aliasing branch in `addJsonbCastsV3` becomes a no-op for synthesized tables. It +stays in place for declared tables, which may still map `createdAt → created_on`. + +### 3. Construction + +```ts +type V3Schemas = Record + +type EncryptedSupabaseV3Options = { + /** Defaults to `process.env.DATABASE_URL`. */ + databaseUrl?: string + /** Passed through to `EncryptionV3`. */ + config?: ClientConfig + /** Optional. See "Optional schemas". */ + schemas?: S +} + +// url + key +export async function encryptedSupabaseV3( + supabaseUrl: string, + supabaseKey: string, + options: EncryptedSupabaseV3Options & { schemas: S }, +): Promise> +export async function encryptedSupabaseV3( + supabaseUrl: string, + supabaseKey: string, + options?: EncryptedSupabaseV3Options, +): Promise + +// existing client +export async function encryptedSupabaseV3( + supabaseClient: SupabaseClientLike, + options: EncryptedSupabaseV3Options & { schemas: S }, +): Promise> +export async function encryptedSupabaseV3( + supabaseClient: SupabaseClientLike, + options?: EncryptedSupabaseV3Options, +): Promise +``` + +The `schemas`-bearing overload precedes the bare one in declaration order, so +TypeScript selects it whenever `schemas` is present and infers `S` from the +value. + +The factory creates (or accepts) a Supabase client, introspects over +`databaseUrl ?? process.env.DATABASE_URL`, synthesizes tables, builds the +encryption client via `EncryptionV3`, and returns `{ from(tableName) }`. + +Accepting an existing client is required: SSR apps hand the adapter a client +that already carries an auth session, and `withLockContext` depends on that +identity. + +If neither `databaseUrl` nor `DATABASE_URL` is present, throw at construction +with a message naming both. + +`from()` resolves the table from the introspected map and passes the synthesized +`EncryptedTable` to `EncryptedQueryBuilderV3Impl`, unchanged. + +### 4. Optional schemas + +Types cannot be derived from an `await`. Introspection runs at runtime, so +`from('users')` sees only a string literal at compile time. Deriving the schema +from the database therefore *necessarily* costs compile-time type safety. + +The resolution is to invert introspection's role when a schema is supplied: it +verifies rather than derives. + +```ts +const users = encryptedTable('users', { + email: types.TextSearch('email'), + amount: types.IntegerOrd('amount'), + active: types.Boolean('active'), +}) + +const supabase = await encryptedSupabaseV3(url, key, { schemas: { users } }) +``` + +`from('users')` still takes no schema argument. The instance is generic over +`typeof schemas`, so the table name is constrained to the declared keys and the +builder resolves to `EncryptedQueryBuilderV3>`. + +This mirrors `createClient(url, key)` — schema on the client, naked +`from()` — except the generic is inferred from a value rather than supplied by +hand. It matches Drizzle's `drizzle(client, { schema })`. + +Two overloads: + +- **Without `schemas`** — `from(tableName: string)` accepts an optional row + generic, returning the untyped builder. Rows are `Record`. +- **With `schemas: S`** — `from(table: K)` returns + `EncryptedQueryBuilderV3>`. + +Adoption is a **gradient**, not a switch: declare one table, leave the rest +introspected. Declared tables get types; undeclared tables behave exactly as +they would with no `schemas` at all. + +#### Verification + +For every declared column, assert the column exists and its introspected +`domain_name` matches the declared `eqlType`. Mismatch throws at construction, +naming table, column, declared domain, and actual domain. + +`types.TextSearch('email')` against a column that is actually `public.text_eq` +fails at startup, instead of a `23514` CHECK violation on the first query. +Neither the current code nor codegen offers this: codegen'd types are correct +only until the next migration. + +Declaring a table that does not exist, or a column that does not exist, is an +error. Declaring a *subset* of a table's encrypted columns is not — undeclared +columns are synthesized from their domains. + +#### Runtime effect of declaring + +For 46 of the 47 domains, a synthesized column and a declared column emit a +**byte-identical** encrypt config. `columns.ts` defines 42 subclasses and +exactly one `override build()`; every other class inherits + +```ts +build(): ColumnSchema { + return { + cast_as: this.definition.castAs, + indexes: indexesForCapabilities(this.definition.capabilities, this.definition.castAs), + } +} +``` + +— a pure function of `{ castAs, capabilities }`, which is a pure function of the +domain name. Declaring such a column adds types and verification, nothing else. + +`EncryptedTextSearchColumn` (`columns.ts:470`) is the sole exception: it carries +`matchOpts` and overrides `build()` to replace the `match` index block. Its +constructor initialises `defaultMatchOpts()`, and `indexesForCapabilities` +(`columns.ts:355`) emits the same defaults for the freeTextSearch capability — +so even a `text_search` column is byte-identical when synthesized, **unless the +caller invoked `.freeTextSearch(opts)`**. + +Therefore the rule is: + +- **Column declared** — verify the domain matches, then use the *declared* + builder, which carries any tuned match options. +- **Column not declared** — synthesize from the introspected domain. + +The single observable consequence: the `include_original: false` caveat +documented on `EncryptedQueryBuilderV3Impl` can only be honoured on a declared +`text_search` column. Substring `like` against an undeclared `text_search` +column will not match, because the default `include_original: true` puts the +whole pattern into the bloom filter as an extra token. + +This asymmetry must be documented on the `schemas` option, not only here. + +### 5. Dependencies + +`pg` becomes a dependency of the Supabase entrypoint. It is already a CLI +dependency. Declare it as an optional peer and load it with a dynamic import so +bundlers do not pull it in unless introspection runs. + +This means `encryptedSupabaseV3` cannot run in a Worker or the browser: it needs +a Postgres socket. That is a real narrowing of where the adapter runs, and it is +inherent to introspecting at connect time. Supplying `schemas` does not avoid +it — verification still connects. + +## Components + +| Unit | Responsibility | Depends on | +|---|---|---| +| `eql/v3/domain-registry.ts` | `domain_name` → column factory | `eql/v3/types` (the `types` factories) | +| `supabase/introspect.ts` | Read `information_schema`, return tables + columns + domains | `pg` | +| `supabase/schema-builder.ts` | Rows → `EncryptedTable[]`; merge declared over synthesized | registry, `eql/v3/table` | +| `supabase/verify.ts` | Declared schema vs introspected reality | introspect output | +| `supabase/index.ts` | Factory: client, introspect, verify, `EncryptionV3`, `from()` | all of the above | + +`query-builder.ts` and `query-builder-v3.ts` are unchanged apart from removing +the `select('*')` throw and threading the full column list for expansion. + +## Data flow + +``` +encryptedSupabaseV3(url, key, { schemas? }) + ├─ createClient(url, key) (or accept a client) + ├─ introspect(databaseUrl) → [{ table, column, domain_name }] + ├─ registry lookup → synthesized EncryptedTable[] + ├─ if schemas: verify + override → declared builders win + ├─ EncryptionV3({ schemas: tables }) → EncryptionClient + └─ { from(tableName) } → EncryptedQueryBuilderV3Impl +``` + +## Error handling + +| Condition | Behaviour | +|---|---| +| No `databaseUrl` and no `DATABASE_URL` | Throw at construction, naming both | +| Introspection connection failure | Throw at construction, with the pg error | +| Declared table absent from database | Throw, naming the table | +| Declared column absent from table | Throw, naming table + column | +| Declared domain ≠ actual domain | Throw, naming both domains | +| Unknown `domain_name` in database | Treated as plaintext, no error | +| `from()` on an unknown table | Throw, naming the table | +| Filter on storage-only column | Compile error if declared; runtime throw otherwise (existing behaviour, `query-builder-v3.ts:180`) | + +## Testing + +- **Unit** — `DOMAIN_REGISTRY` exhaustiveness against every `eqlType` in + `columns.ts`. Rows → `EncryptedTable[]` grouping. Verification: match, + wrong-domain, missing column, missing table. Declared-over-synthesized + override, including that a declared `TextSearch` retains its tuner options. +- **Live Postgres** — introspection against a table with mixed encrypted and + plaintext columns, asserting the domain→builder round-trip. + + **Setup dependency.** The compose image (`postgres-eql:17-2.3.1`, + `local/docker-compose.yml`) reports `eql_v3.version()` as `DEV` but contains + **zero domains** in `public` — the concrete-domain surface is absent. The 47 + domains exist only after applying this branch's + `packages/cli/src/sql/cipherstash-encrypt-v3.sql`. Live introspection tests + must apply that SQL first, as the existing v3 pg tests do; they cannot run + against the stock image. +- **Wire encoding** — existing `supabase-v3-builder.test.ts` mock-client tests + continue to pass unchanged, with the builder constructed from a synthesized + table rather than a declared one. +- **Types** — `supabase-v3.test-d.ts` splits: the existing four guarantees are + re-pinned under `{ schemas }`, and a new block asserts the untyped surface + without `schemas` (rows are `Record`; `from` accepts any + string). + +## Out of scope + +- **Codegen.** `stash gen types` emitting the v3 table objects from the same + `information_schema` query. The API does not change when it lands — callers + stop hand-writing `users` and import it instead. Deferred deliberately: make + it work before generating it. +- **v2.** `encryptedSupabase` keeps its current signature and behaviour. +- **PostgREST-only introspection.** Neither `@supabase/supabase-js` nor + `@supabase/postgrest-js` exposes any introspection API (verified: no + `openapi`/`swagger`/`introspect` surface in either package; `schema()` only + swaps the `Accept-Profile` header). PostgREST's OpenAPI root document is the + only non-Postgres runtime source, and whether it names a column's domain or + flattens it to `jsonb` is unverified. If it names the domain, a future + increment can drop the `pg` dependency and restore Worker/browser support. diff --git a/e2e/tests/package-managers.e2e.test.ts b/e2e/tests/package-managers.e2e.test.ts index 85f65414b..52df50afc 100644 --- a/e2e/tests/package-managers.e2e.test.ts +++ b/e2e/tests/package-managers.e2e.test.ts @@ -56,7 +56,8 @@ describe('CLI init providers — package-manager-aware Next Steps', () => { { label: 'drizzle', create: createDrizzleProvider, - firstStep: (r) => `Set up your database: ${r} stash eql install --drizzle`, + firstStep: (r) => + `Set up your database: ${r} stash eql install --drizzle`, }, { label: 'supabase', diff --git a/e2e/wasm/roundtrip.test.ts b/e2e/wasm/roundtrip.test.ts index 23e452907..03e172b90 100644 --- a/e2e/wasm/roundtrip.test.ts +++ b/e2e/wasm/roundtrip.test.ts @@ -1,25 +1,29 @@ /** * WASM smoke test for `@cipherstash/stack/wasm-inline`. * - * Runs under Deno against real CipherStash credentials. Proves three - * things together: + * Runs under Deno against real CipherStash credentials. Proves four things + * together: * 1. The stack `/wasm-inline` subpath resolves under Deno (no native * binding required). - * 2. The WASM protect-ffi client can complete an encrypt → decrypt - * round-trip against ZeroKMS / CTS. - * 3. No FFI permission was granted to the Deno process, so the WASM - * path is the *only* path that could have succeeded. + * 2. The entry is EQL v3: a schema authored with the `types` DSL round-trips. + * `TextSearch` maps to the concrete `eql_v3_text_search` domain, which a + * v2-mode client cannot resolve — so a successful round-trip proves the + * factory pinned `eqlVersion: 3` (#614). + * 3. The WASM protect-ffi client completes an encrypt → decrypt round-trip + * against ZeroKMS / CTS. + * 4. No FFI permission was granted to the Deno process, so the WASM path is + * the *only* path that could have succeeded. * - * Skipped when any of the four CS_* env vars is missing — matches the - * skip pattern in `e2e/tests/*.e2e.test.ts`. + * Skipped when any of the four CS_* env vars is missing — matches the skip + * pattern in `e2e/tests/*.e2e.test.ts`. */ import { assertEquals, assertExists } from 'jsr:@std/assert@^1.0.0' import { Encryption, - encryptedColumn, encryptedTable, isEncrypted, + types, } from '@cipherstash/stack/wasm-inline' // `CS_WORKSPACE_CRN` is the single source of truth for workspace @@ -46,7 +50,7 @@ function envOrSkip(): Record<(typeof REQUIRED_ENV)[number], string> | null { const env = envOrSkip() Deno.test({ - name: 'stack/wasm-inline: encrypt → decrypt round-trip via WASM', + name: 'stack/wasm-inline: EQL v3 encrypt → decrypt round-trip via WASM', ignore: env === null, permissions: { env: true, @@ -66,8 +70,11 @@ Deno.test({ 'Deno global missing (test framework misconfigured)', ) + // A v3 table authored with the `types` DSL re-exported from `/wasm-inline`. + // `TextSearch` maps to `eql_v3_text_search`, which only a v3-mode client + // can resolve — so this round-trip proves the factory selected eqlVersion 3. const users = encryptedTable('protect-ci', { - email: encryptedColumn('email'), + email: types.TextSearch('email'), }) const client = await Encryption({ @@ -82,7 +89,7 @@ Deno.test({ }, }) - const plaintext = `wasm-smoke-${crypto.randomUUID()}@example.com` + const plaintext = `wasm-v3-smoke-${crypto.randomUUID()}@example.com` const encrypted = await client.encrypt(plaintext, { column: users.email, diff --git a/examples/basic/package.json b/examples/basic/package.json index 87c6c8fd9..8a2f8e242 100644 --- a/examples/basic/package.json +++ b/examples/basic/package.json @@ -12,6 +12,8 @@ "description": "", "dependencies": { "@cipherstash/stack": "workspace:*", + "@cipherstash/stack-drizzle": "workspace:*", + "@cipherstash/stack-supabase": "workspace:*", "dotenv": "^17.4.2", "pg": "8.20.0" }, diff --git a/examples/basic/src/encryption/index.ts b/examples/basic/src/encryption/index.ts index c7290f7a6..4f78be08e 100644 --- a/examples/basic/src/encryption/index.ts +++ b/examples/basic/src/encryption/index.ts @@ -2,7 +2,7 @@ import { Encryption } from '@cipherstash/stack' import { encryptedType, extractEncryptionSchema, -} from '@cipherstash/stack/drizzle' +} from '@cipherstash/stack-drizzle' import { integer, pgTable, timestamp } from 'drizzle-orm/pg-core' export const usersTable = pgTable('users', { diff --git a/examples/basic/src/lib/supabase/encrypted.ts b/examples/basic/src/lib/supabase/encrypted.ts index 816b0cd65..147930987 100644 --- a/examples/basic/src/lib/supabase/encrypted.ts +++ b/examples/basic/src/lib/supabase/encrypted.ts @@ -1,4 +1,4 @@ -import { encryptedSupabase } from '@cipherstash/stack/supabase' +import { encryptedSupabase } from '@cipherstash/stack-supabase' import { contactsTable, encryptionClient } from '../../encryption/index' import { createServerClient } from './server' diff --git a/examples/prisma/migrations/app/20260709T1034_initial/migration.ts b/examples/prisma/migrations/app/20260709T1034_initial/migration.ts index 11c035c3a..711d9eb64 100755 --- a/examples/prisma/migrations/app/20260709T1034_initial/migration.ts +++ b/examples/prisma/migrations/app/20260709T1034_initial/migration.ts @@ -1,13 +1,18 @@ #!/usr/bin/env -S node -import { cipherstashAddSearchConfig } from '@prisma-next/extension-cipherstash/migration'; -import { Migration, MigrationCLI, col, primaryKey } from '@prisma-next/postgres/migration'; +import { cipherstashAddSearchConfig } from '@prisma-next/extension-cipherstash/migration' +import { + col, + Migration, + MigrationCLI, + primaryKey, +} from '@prisma-next/postgres/migration' export default class M extends Migration { override describe() { return { from: null, to: 'sha256:b8c4febc9397cf1b68293cdb3b2afe9f568db6967f428e3f207e32575a2bc2fa', - }; + } } override get operations() { @@ -34,17 +39,30 @@ export default class M extends Migration { notNull: true, codecRef: { codecId: 'cipherstash/string@1', - typeParams: { equality: true, freeTextSearch: true, orderAndRange: true }, + typeParams: { + equality: true, + freeTextSearch: true, + orderAndRange: true, + }, }, }), col('emailverified', 'eql_v2_encrypted', { notNull: true, - codecRef: { codecId: 'cipherstash/boolean@1', typeParams: { equality: true } }, + codecRef: { + codecId: 'cipherstash/boolean@1', + typeParams: { equality: true }, + }, + }), + col('id', 'text', { + notNull: true, + codecRef: { codecId: 'pg/text@1' }, }), - col('id', 'text', { notNull: true, codecRef: { codecId: 'pg/text@1' } }), col('preferences', 'eql_v2_encrypted', { notNull: true, - codecRef: { codecId: 'cipherstash/json@1', typeParams: { searchableJson: true } }, + codecRef: { + codecId: 'cipherstash/json@1', + typeParams: { searchableJson: true }, + }, }), col('salary', 'eql_v2_encrypted', { notNull: true, @@ -80,9 +98,21 @@ export default class M extends Migration { index: 'ore', castAs: 'date', }), - cipherstashAddSearchConfig({ table: 'users', column: 'email', index: 'unique' }), - cipherstashAddSearchConfig({ table: 'users', column: 'email', index: 'match' }), - cipherstashAddSearchConfig({ table: 'users', column: 'email', index: 'ore' }), + cipherstashAddSearchConfig({ + table: 'users', + column: 'email', + index: 'unique', + }), + cipherstashAddSearchConfig({ + table: 'users', + column: 'email', + index: 'match', + }), + cipherstashAddSearchConfig({ + table: 'users', + column: 'email', + index: 'ore', + }), cipherstashAddSearchConfig({ table: 'users', column: 'emailverified', @@ -107,8 +137,8 @@ export default class M extends Migration { index: 'ore', castAs: 'double', }), - ]; + ] } } -MigrationCLI.run(import.meta.url, M); +MigrationCLI.run(import.meta.url, M) diff --git a/examples/prisma/src/index.ts b/examples/prisma/src/index.ts index 885d3cddf..02320c81c 100644 --- a/examples/prisma/src/index.ts +++ b/examples/prisma/src/index.ts @@ -118,7 +118,9 @@ async function main() { } async function clearUsers(): Promise { - const removed = await db.orm.public.User.where((u) => u.id.isNotNull()).deleteCount() + const removed = await db.orm.public.User.where((u) => + u.id.isNotNull(), + ).deleteCount() if (removed > 0) { console.log(`--- Cleanup ---\nRemoved ${removed} existing user row(s).\n`) } @@ -212,7 +214,9 @@ async function equalityQueryOnEmailVerified(): Promise { async function sortByEmailAsc(): Promise { console.log('\n--- cipherstashAsc (bare-column ORDER BY) ---') - const rows = await db.orm.public.User.orderBy((u) => cipherstashAsc(u.email)).all() + const rows = await db.orm.public.User.orderBy((u) => + cipherstashAsc(u.email), + ).all() await decryptAll(rows) for (const row of rows) { console.log(` ${row.id}: email=${await row.email.decrypt()}`) diff --git a/examples/prisma/test/e2e/global-setup.ts b/examples/prisma/test/e2e/global-setup.ts index 3fb218342..82c7dafdb 100644 --- a/examples/prisma/test/e2e/global-setup.ts +++ b/examples/prisma/test/e2e/global-setup.ts @@ -119,20 +119,14 @@ export default async function setup(): Promise<() => Promise> { // is for the `pnpm start` demo loop). process.env['DATABASE_URL'] = HARNESS_DATABASE_URL - const apply = spawnSync( - 'pnpm', - ['exec', 'prisma-next', 'migrate', '--yes'], - { - cwd: exampleDir, - stdio: 'pipe', - env: process.env, - timeout: MIGRATION_APPLY_TIMEOUT_MS, - }, - ) + const apply = spawnSync('pnpm', ['exec', 'prisma-next', 'migrate', '--yes'], { + cwd: exampleDir, + stdio: 'pipe', + env: process.env, + timeout: MIGRATION_APPLY_TIMEOUT_MS, + }) if (apply.error || apply.signal || apply.status !== 0) { - throw new Error( - describeSpawnFailure('`prisma-next migrate`', apply), - ) + throw new Error(describeSpawnFailure('`prisma-next migrate`', apply)) } // Clean slate for the suite. The `users` table is the only data-bearing diff --git a/examples/prisma/test/e2e/str-range.e2e.test.ts b/examples/prisma/test/e2e/str-range.e2e.test.ts index c98bda626..e8d4e2295 100644 --- a/examples/prisma/test/e2e/str-range.e2e.test.ts +++ b/examples/prisma/test/e2e/str-range.e2e.test.ts @@ -74,7 +74,9 @@ describe('EncryptedString orderAndRange e2e (live PG + EQL + ZeroKMS)', () => { }) it('cipherstashAsc orders alphabetically (bare-column ORDER BY on string)', async () => { - const rows = await db.orm.public.User.orderBy((u) => cipherstashAsc(u.email)).all() + const rows = await db.orm.public.User.orderBy((u) => + cipherstashAsc(u.email), + ).all() expect(rows.map((r) => r.id)).toEqual([ 'e2e-str-0', 'e2e-str-1', diff --git a/local/docker-compose.postgres.yml b/local/docker-compose.postgres.yml new file mode 100644 index 000000000..81ce55bef --- /dev/null +++ b/local/docker-compose.postgres.yml @@ -0,0 +1,44 @@ +# Plain Postgres for the Drizzle v3 integration suite. +# +# Drizzle talks straight to Postgres, so there is no PostgREST here and no +# anon/authenticated role surface — that is the Supabase variant's job. +# +# Ports are deliberately NOT the defaults. A developer running this is very +# likely also running `local/docker-compose.yml`, a `supabase start` stack, or +# their own Postgres on 5432. Binding 5432 here would either fail to start or, +# worse, shadow the database they think they are talking to. +# +# Connect DIRECT to the database, never through a pooler: `SET ROLE` and session +# advisory locks (both used by the EQL installer) are unstable over PgBouncer in +# transaction mode. +name: cs-integration-postgres + +services: + postgres: + # Ships EQL v2 preinstalled; EQL v3 is installed by the harness via + # `stash eql install --eql-version 3`, which is the point — the integration + # suites exercise the installer customers actually run. + image: ghcr.io/cipherstash/postgres-eql:17-2.3.1 + environment: + PGPORT: 5432 + POSTGRES_DB: cipherstash + POSTGRES_USER: cipherstash + PGUSER: cipherstash + POSTGRES_PASSWORD: password + ports: + - "55432:5432" + # No volume: every run starts from a clean database, so a stale EQL + # generation can never make a suite pass for the wrong reason. + # + # `-h 127.0.0.1` is load-bearing. During init the entrypoint runs a TEMPORARY + # server that listens on the unix socket ONLY; a socket-based `pg_isready` + # succeeds against it, so `up --wait` returns while the real server is still + # restarting and the next connection dies with "Connection terminated + # unexpectedly" (observed: the EQL install failed exactly there). TCP is not + # published until the final server is up, so probing it is the honest check. + healthcheck: + test: ["CMD-SHELL", "pg_isready -h 127.0.0.1 -U cipherstash -d cipherstash"] + interval: 1s + timeout: 5s + start_period: 5s + retries: 30 diff --git a/local/docker-compose.supabase.yml b/local/docker-compose.supabase.yml new file mode 100644 index 000000000..4931db194 --- /dev/null +++ b/local/docker-compose.supabase.yml @@ -0,0 +1,83 @@ +# Supabase-flavoured Postgres + PostgREST for the Supabase v3 integration suite. +# +# `supabase/postgres` rather than the plain `postgres-eql` image, because the +# thing under test is what a managed Supabase project actually does: the +# `postgres` role is NOT a superuser there (verified: `pg_roles.rolsuper = f`), +# and the EQL v3 install, the `ALTER DEFAULT PRIVILEGES FOR ROLE postgres` in the +# grants block, and the ORE opclass self-skip all behave differently under that +# constraint. A plain Postgres would make every privilege check pass vacuously. +# +# NOT the full `supabase start` stack: no Kong, GoTrue, Studio or Storage. The +# adapter speaks PostgREST, and PostgREST is what we run. +# +# Images are pinned by DIGEST, not tag — Supabase re-pushes tags. +# +# Ports are deliberately NOT the defaults. A developer running this very likely +# also has `local/docker-compose.yml`, a `supabase start` stack, or their own +# Postgres bound to 5432/3000. Binding those here would either fail to start or, +# worse, silently shadow the database they think they are talking to. +# +# Connect DIRECT to the database, never through a pooler: `SET ROLE` and session +# advisory locks (both used by the EQL installer) are unstable over PgBouncer in +# transaction mode. +name: cs-integration-supabase + +services: + db: + image: supabase/postgres:17.4.1.048@sha256:68f90b9a227f56b583d2c1aef2fc683c4dc693a3c5ebf5191903e966318d87ee + environment: + POSTGRES_PASSWORD: password + ports: + - "55433:5432" + volumes: + # Supplies the one thing the image omits: a password for `authenticator`. + # + # The `zz-` prefix is load-bearing. The Postgres entrypoint runs + # `/docker-entrypoint-initdb.d/*` in ASCII order, and this image creates + # its roles from `migrate.sh` in that same directory. A `99-` prefix sorts + # BEFORE `migrate.sh` (`'9' < 'm'`), so the script would run against a + # database where `authenticator` does not exist yet and abort the boot. + - ./supabase-init.sql:/docker-entrypoint-initdb.d/zz-cipherstash-authenticator.sql:ro + # No volume for PGDATA: every run starts clean, so a stale EQL generation can + # never make a suite pass for the wrong reason. + # + # `pg_isready` is NOT a sufficient readiness check here. This image boots a + # temporary server to run `migrate.sh`, then restarts it; `pg_isready` + # succeeds against the temporary one, so `up --wait` returns while the real + # server is still coming up and the next connection dies with "Connection + # terminated unexpectedly" (observed: the EQL install failed exactly there). + # + # Probe the LAST thing init does instead — the `authenticator` password set + # by our `zz-` script. It is true only once every init step has run. + healthcheck: + test: + - CMD-SHELL + - psql -U postgres -d postgres -tAc "SELECT 1 FROM pg_authid WHERE rolname='authenticator' AND rolpassword IS NOT NULL" | grep -q 1 + interval: 2s + timeout: 5s + start_period: 10s + retries: 60 + + postgrest: + image: postgrest/postgrest:v12.2.12@sha256:be3b6ab31a94e3e89f08edad40be0234ae0951e3297f2043d797c219165f5afa + depends_on: + db: + condition: service_healthy + environment: + # Connect as `authenticator`, then SET ROLE to `anon` for unauthenticated + # requests. Pointing PostgREST at the owner instead would make every grant + # check pass vacuously — proving the Supabase grants work is half the point. + PGRST_DB_URI: "postgres://authenticator:authpass@db:5432/postgres" + PGRST_DB_SCHEMAS: public + PGRST_DB_ANON_ROLE: anon + # Lets `NOTIFY pgrst, 'reload schema'` reach the server, so a table created + # after boot becomes visible without a restart. + PGRST_DB_CHANNEL_ENABLED: "true" + ports: + - "55430:3000" + # No healthcheck: the postgrest image is distroless — it has no shell, no + # wget, no curl, so every in-container probe fails with "executable file not + # found" and `docker compose up --wait` reports the service unhealthy while + # it is in fact serving. Readiness is asserted from the harness instead, by + # polling the root endpoint until the table under test appears in the OpenAPI + # output — which is what actually has to be true before a suite can run. diff --git a/local/docker-compose.yml b/local/docker-compose.yml index bec67077c..c670c1e61 100644 --- a/local/docker-compose.yml +++ b/local/docker-compose.yml @@ -11,6 +11,10 @@ services: POSTGRES_PASSWORD: password ports: - 5432:5432 + volumes: + # Creates anon / authenticated / service_role / postgres / authenticator + # before PostgREST first connects. See the file for why. + - ./postgrest-roles.sql:/docker-entrypoint-initdb.d/00-postgrest-roles.sql:ro deploy: resources: limits: @@ -22,3 +26,22 @@ services: interval: 1s timeout: 5s retries: 10 + + postgrest: + # Pinned, matching the discipline the postgres service already follows. + image: postgrest/postgrest:v12.2.12 + depends_on: + postgres: + condition: service_healthy + environment: + # Connect as `authenticator`, then SET ROLE to `anon` for unauthenticated + # requests. Running as the DB OWNER instead would make every grant check + # pass vacuously — the suite exists to prove the Supabase grants work. + PGRST_DB_URI: "postgres://authenticator:authpass@postgres:5432/cipherstash" + PGRST_DB_SCHEMAS: public + PGRST_DB_ANON_ROLE: anon + # Lets `NOTIFY pgrst, 'reload schema'` reach the server. + PGRST_DB_CHANNEL_ENABLED: "true" + ports: + - 3000:3000 + restart: always diff --git a/local/postgrest-roles.sql b/local/postgrest-roles.sql new file mode 100644 index 000000000..d6800e303 --- /dev/null +++ b/local/postgrest-roles.sql @@ -0,0 +1,35 @@ +-- Roles PostgREST needs, created at database init. +-- +-- `authenticator` is the role PostgREST CONNECTS as; it must be able to +-- `SET ROLE` to `anon`, so it is a member of it and NOINHERIT (it gets anon's +-- rights only after switching, never ambiently). This is PostgREST's documented +-- convention and it is what makes the live suite exercise the Supabase grants +-- rather than the owner's ambient superuser rights — pointing +-- PGRST_DB_ANON_ROLE at the owner would make every permission check pass +-- vacuously and prove nothing. +-- +-- `postgres` exists only because the shipped grants block says +-- `ALTER DEFAULT PRIVILEGES FOR ROLE postgres`; a plain Postgres image has no +-- such role. +DO $$ +BEGIN + IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'anon') THEN + CREATE ROLE anon NOLOGIN; + END IF; + IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'authenticated') THEN + CREATE ROLE authenticated NOLOGIN; + END IF; + IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'service_role') THEN + CREATE ROLE service_role NOLOGIN; + END IF; + IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'postgres') THEN + CREATE ROLE postgres NOLOGIN; + END IF; + IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'authenticator') THEN + CREATE ROLE authenticator LOGIN PASSWORD 'authpass' NOINHERIT; + END IF; +END +$$; + +GRANT anon, authenticated TO authenticator; +GRANT USAGE ON SCHEMA public TO anon, authenticated, service_role; diff --git a/local/supabase-init.sql b/local/supabase-init.sql new file mode 100644 index 000000000..2bcd11cd5 --- /dev/null +++ b/local/supabase-init.sql @@ -0,0 +1,32 @@ +-- Make `authenticator` usable by PostgREST. +-- +-- `supabase/postgres` already ships `anon`, `authenticated`, `service_role` and +-- `authenticator`, and `authenticator` is already `LOGIN NOINHERIT` and already a +-- member of the other three. What it does NOT ship is a password (`pg_authid` +-- reports `rolpassword IS NULL`), so PostgREST cannot connect. That is the only +-- thing this file supplies. +-- +-- Do NOT reuse `local/postgrest-roles.sql` here. It is written for plain +-- Postgres, where the roles do not exist: its `CREATE ROLE ... IF NOT EXISTS` +-- branch sets the password only on first create, so against an image that +-- already has `authenticator` the password is silently never set and PostgREST +-- fails to authenticate. +-- +-- Runs as `supabase_admin` via /docker-entrypoint-initdb.d, which is the image's +-- superuser — and it must, because `authenticator` is a RESERVED role that even +-- the `postgres` role cannot modify (`ERROR: "authenticator" is a reserved role, +-- only superusers can modify it`). It therefore cannot be done from the harness. +-- +-- It must also be mounted with a filename that sorts AFTER `migrate.sh`, which is +-- where this image creates the roles. See the compose file. +-- +-- Nothing else in the integration harness needs a superuser: the EQL v3 install +-- runs as the non-superuser `postgres` role, exactly as a customer's Supabase +-- project does. + +ALTER ROLE authenticator WITH LOGIN PASSWORD 'authpass' NOINHERIT; + +-- Idempotent no-ops on this image, kept so the file also works against a plain +-- Postgres that has had the roles created some other way. +GRANT anon, authenticated, service_role TO authenticator; +GRANT USAGE ON SCHEMA public TO anon, authenticated, service_role; diff --git a/package.json b/package.json index b2b52e249..bdadaa2bf 100644 --- a/package.json +++ b/package.json @@ -28,6 +28,7 @@ "dev": "turbo dev --filter './packages/*'", "clean": "rimraf --glob **/.next **/.turbo **/dist **/node_modules", "code:fix": "biome check --write", + "code:check": "biome check", "lint:runners": "node scripts/lint-no-hardcoded-runners.mjs", "lint:workflow-cache": "node scripts/lint-no-workflow-caching.mjs", "release": "pnpm run build && changeset publish", diff --git a/packages/bench/__benches__/drizzle/operators.bench.ts b/packages/bench/__benches__/drizzle/operators.bench.ts index 7c931bc6c..4dd7c99af 100644 --- a/packages/bench/__benches__/drizzle/operators.bench.ts +++ b/packages/bench/__benches__/drizzle/operators.bench.ts @@ -1,4 +1,4 @@ -import { createEncryptionOperators } from '@cipherstash/stack/drizzle' +import { createEncryptionOperators } from '@cipherstash/stack-drizzle' import type { SQL } from 'drizzle-orm' import { afterAll, beforeAll, bench, describe } from 'vitest' import { diff --git a/packages/bench/__tests__/drizzle/operators.explain.test.ts b/packages/bench/__tests__/drizzle/operators.explain.test.ts index 1c2bac899..9aec76d4f 100644 --- a/packages/bench/__tests__/drizzle/operators.explain.test.ts +++ b/packages/bench/__tests__/drizzle/operators.explain.test.ts @@ -1,7 +1,7 @@ import { mkdirSync, writeFileSync } from 'node:fs' import { dirname, resolve } from 'node:path' import { fileURLToPath } from 'node:url' -import { createEncryptionOperators } from '@cipherstash/stack/drizzle' +import { createEncryptionOperators } from '@cipherstash/stack-drizzle' import type { SQL } from 'drizzle-orm' import { afterAll, beforeAll, describe, expect, it } from 'vitest' import { diff --git a/packages/bench/package.json b/packages/bench/package.json index 7dc4d94e0..62318993f 100644 --- a/packages/bench/package.json +++ b/packages/bench/package.json @@ -12,6 +12,7 @@ }, "dependencies": { "@cipherstash/stack": "workspace:*", + "@cipherstash/stack-drizzle": "workspace:*", "drizzle-orm": "0.45.2", "pg": "^8.20.0" }, diff --git a/packages/bench/src/drizzle/setup.ts b/packages/bench/src/drizzle/setup.ts index 35490df43..944ece227 100644 --- a/packages/bench/src/drizzle/setup.ts +++ b/packages/bench/src/drizzle/setup.ts @@ -1,9 +1,9 @@ import { Encryption } from '@cipherstash/stack' +import type { EncryptionClient } from '@cipherstash/stack/encryption' import { encryptedType, extractEncryptionSchema, -} from '@cipherstash/stack/drizzle' -import type { EncryptionClient } from '@cipherstash/stack/encryption' +} from '@cipherstash/stack-drizzle' import { drizzle } from 'drizzle-orm/node-postgres' import { pgTable, serial } from 'drizzle-orm/pg-core' import pg from 'pg' @@ -13,7 +13,7 @@ import { getDatabaseUrl } from '../harness/db.js' * Drizzle schema for the bench table. Mirrors `sql/schema.sql`. * * `id` is `serial`; the encrypted columns are `eql_v2_encrypted` composites - * driven by `@cipherstash/stack/drizzle`'s `encryptedType`. + * driven by `@cipherstash/stack-drizzle`'s `encryptedType`. * * Index config flags (`equality`, `freeTextSearch`, `orderAndRange`, * `searchableJson`) are deliberately all on — the bench needs to exercise diff --git a/packages/cli/package.json b/packages/cli/package.json index fef7f871a..dc8dd8d90 100644 --- a/packages/cli/package.json +++ b/packages/cli/package.json @@ -74,6 +74,7 @@ } }, "devDependencies": { + "@cipherstash/eql": "3.0.0", "@cipherstash/stack": "workspace:*", "@types/pg": "^8.20.0", "node-pty": "^1.1.0", diff --git a/packages/cli/scripts/build-eql-v3-sql.mjs b/packages/cli/scripts/build-eql-v3-sql.mjs index e182ca618..436d3358c 100644 --- a/packages/cli/scripts/build-eql-v3-sql.mjs +++ b/packages/cli/scripts/build-eql-v3-sql.mjs @@ -1,100 +1,57 @@ #!/usr/bin/env node /** - * Vendor the EQL v3 SQL bundles into packages/cli/src/sql/. + * Vendor the EQL v3 SQL bundle into packages/cli/src/sql/. * - * Source of truth: the `cipherstash-encrypt.sql` artifact of the upstream - * `eql-3.0.0-alpha.2` release (cipherstash/encrypt-query-language), vendored - * byte-for-byte at - * packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql. - * To re-vendor: download the release asset, replace the fixture, re-run this - * script, and record the new release tag here. + * Source of truth: the `cipherstash-encrypt.sql` artifact shipped inside the + * pinned `@cipherstash/eql` npm package (a byte-for-byte copy of the matching + * GitHub release asset — the package records the artifact's sha256 in its + * `releaseManifest`, which this script verifies). Bump the `@cipherstash/eql` + * devDependency and re-run this script to re-vendor. * - * Outputs: - * - cipherstash-encrypt-v3.sql — full bundle, byte-identical copy - * - cipherstash-encrypt-v3-supabase.sql — Supabase variant with the - * `CREATE OPERATOR CLASS`/`FAMILY` chunks removed (they need superuser, - * which Supabase does not grant) + * Output: + * - cipherstash-encrypt-v3.sql — full bundle, byte-identical copy * - * The Supabase variant is still derived locally because upstream ships no - * Supabase variant for v3 yet. The strip mirrors the upstream build's - * `**\/*operator_class.sql` exclusion glob: the monolith annotates every - * constituent file with a `--! @file ` marker, so the variant drops each - * `--! @file .../operator_class.sql` chunk up to the next `--! @file` marker. + * There is deliberately NO Supabase / no-operator-family variant for v3. + * Since eql-3.0.0 the bundle installs everywhere with one artifact: its only + * superuser-requiring statements (the ore_block_256 operator class/family) + * run inside a DO block that catches `insufficient_privilege` and skips, and + * a follow-up section disables the ORE-backed encrypted domains when the + * operator class is absent (CIP-3468). Stripping anything client-side would + * only defeat that self-adaptation. * * Usage: node packages/cli/scripts/build-eql-v3-sql.mjs */ +import { createHash } from 'node:crypto' import { readFileSync, writeFileSync } from 'node:fs' +import { createRequire } from 'node:module' import { dirname, resolve } from 'node:path' import { fileURLToPath } from 'node:url' const here = dirname(fileURLToPath(import.meta.url)) -const source = resolve( - here, - '../../stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql', -) -const outDir = resolve(here, '../src/sql') - -const FILE_MARKER = /^--! @file (.+)$/ -const EXCLUDE = /operator_class\.sql$/ - -function stripOperatorClassChunks(sql) { - // \r?\n: a CRLF-checked-out source would otherwise defeat the `$`-anchored - // EXCLUDE match (belt-and-braces — the removedChunks assertion below would - // still catch it loudly). - const lines = sql.split(/\r?\n/) - const out = [] - let skipping = false - let removedChunks = 0 - - for (const line of lines) { - const marker = line.match(FILE_MARKER) - if (marker) { - skipping = EXCLUDE.test(marker[1]) - if (skipping) removedChunks++ - } - if (!skipping) out.push(line) - } - - // Verified against eql-3.0.0-alpha.2: exactly 2 `--! @file .../operator_class.sql` - // chunks (v3/sem/ore_cllw and v3/sem/ore_block_256), together carrying all - // 4 CREATE OPERATOR CLASS/FAMILY statements in the bundle. The OPE path - // (ope_cllw) ships no opclass. Hard-coded so layout drift fails loudly. - if (removedChunks !== 2) { - throw new Error( - `Expected to remove exactly 2 operator_class chunks, removed ${removedChunks} — the bundle layout changed; review the strip logic.`, - ) - } +const require = createRequire(resolve(here, '../package.json')) - const stripped = out.join('\n') - if (/CREATE OPERATOR (CLASS|FAMILY)/.test(stripped)) { - throw new Error( - 'Stripped bundle still contains CREATE OPERATOR CLASS/FAMILY statements.', - ) - } +const manifest = require('@cipherstash/eql/package.json') +const sqlEntry = require.resolve('@cipherstash/eql/sql/cipherstash-encrypt.sql') +const sql = readFileSync(sqlEntry, 'utf8') - return stripped +// Integrity: the package's sql module records the artifact's sha256; verify +// the copy we are about to vendor is exactly that artifact. +const { releaseManifest } = await import('@cipherstash/eql/sql') +const sha = createHash('sha256').update(sql).digest('hex') +if (sha !== releaseManifest.installSqlSha256) { + throw new Error( + `@cipherstash/eql install SQL sha mismatch: expected ${releaseManifest.installSqlSha256}, got ${sha}`, + ) } - -const sql = readFileSync(source, 'utf8') - -// Companion drift check: the full bundle must carry exactly the 4 -// CREATE OPERATOR CLASS/FAMILY statements the 2 stripped chunks account for -// (verified against eql-3.0.0-alpha.2). An opclass appearing outside an -// operator_class.sql chunk would otherwise slip into the Supabase variant -// (the post-strip scan below also guards that; this pins the source shape). -const opclassStatements = sql.match(/CREATE OPERATOR (CLASS|FAMILY)/g) ?? [] -if (opclassStatements.length !== 4) { +if (manifest.version !== releaseManifest.eqlVersion) { throw new Error( - `Expected the source bundle to contain exactly 4 CREATE OPERATOR CLASS/FAMILY statements, found ${opclassStatements.length} — the bundle layout changed; review the strip logic.`, + `@cipherstash/eql package/manifest version mismatch: ${manifest.version} vs ${releaseManifest.eqlVersion}`, ) } +const outDir = resolve(here, '../src/sql') writeFileSync(resolve(outDir, 'cipherstash-encrypt-v3.sql'), sql) -writeFileSync( - resolve(outDir, 'cipherstash-encrypt-v3-supabase.sql'), - stripOperatorClassChunks(sql), -) console.log( - 'Wrote cipherstash-encrypt-v3.sql and cipherstash-encrypt-v3-supabase.sql', + `Vendored cipherstash-encrypt-v3.sql from @cipherstash/eql@${manifest.version} (sha256 ${sha})`, ) diff --git a/packages/cli/src/__tests__/config.test.ts b/packages/cli/src/__tests__/config.test.ts index d3094584f..5189bc2f7 100644 --- a/packages/cli/src/__tests__/config.test.ts +++ b/packages/cli/src/__tests__/config.test.ts @@ -54,37 +54,34 @@ describe('loadStashConfig', () => { it.each([ ['stash', `Cannot find module 'stash'`], ['@cipherstash/stack', `Cannot find package '@cipherstash/stack'`], - ])( - 'translates a missing `%s` module into actionable guidance (#579)', - async (pkg, message) => { - fs.writeFileSync( - path.join(tmpDir, 'stash.config.ts'), - `import 'stash'\nexport default {}`, - ) - process.cwd = () => tmpDir - vi.spyOn(process, 'exit').mockImplementation(() => { - throw new Error('process.exit') - }) - const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}) - - const moduleErr = Object.assign(new Error(message), { - code: 'MODULE_NOT_FOUND', - }) - const { createJiti } = await import('jiti') - vi.mocked(createJiti).mockReturnValue({ - import: vi.fn().mockRejectedValue(moduleErr), - } as never) - - const { loadStashConfig } = await import('@/config/index.ts') - await expect(loadStashConfig()).rejects.toThrow('process.exit') - - const output = errorSpy.mock.calls.map((c) => c.join(' ')).join('\n') - expect(output).toContain(`\`${pkg}\` is not installed`) - expect(output).toContain('stash init') - // The raw jiti stack trace must NOT be forwarded to the user. - expect(output).not.toContain('Failed to load') - }, - ) + ])('translates a missing `%s` module into actionable guidance (#579)', async (pkg, message) => { + fs.writeFileSync( + path.join(tmpDir, 'stash.config.ts'), + `import 'stash'\nexport default {}`, + ) + process.cwd = () => tmpDir + vi.spyOn(process, 'exit').mockImplementation(() => { + throw new Error('process.exit') + }) + const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}) + + const moduleErr = Object.assign(new Error(message), { + code: 'MODULE_NOT_FOUND', + }) + const { createJiti } = await import('jiti') + vi.mocked(createJiti).mockReturnValue({ + import: vi.fn().mockRejectedValue(moduleErr), + } as never) + + const { loadStashConfig } = await import('@/config/index.ts') + await expect(loadStashConfig()).rejects.toThrow('process.exit') + + const output = errorSpy.mock.calls.map((c) => c.join(' ')).join('\n') + expect(output).toContain(`\`${pkg}\` is not installed`) + expect(output).toContain('stash init') + // The raw jiti stack trace must NOT be forwarded to the user. + expect(output).not.toContain('Failed to load') + }) it('still surfaces the raw error for unrelated config load failures', async () => { fs.writeFileSync(path.join(tmpDir, 'stash.config.ts'), 'export default {}') @@ -157,7 +154,9 @@ describe('loadEncryptConfig', () => { let originalCwd: () => string beforeEach(() => { - tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'stash-encrypt-config-test-')) + tmpDir = fs.mkdtempSync( + path.join(os.tmpdir(), 'stash-encrypt-config-test-'), + ) originalCwd = process.cwd }) diff --git a/packages/cli/src/__tests__/installer.test.ts b/packages/cli/src/__tests__/installer.test.ts index 6ed9eb914..5ee0bd32e 100644 --- a/packages/cli/src/__tests__/installer.test.ts +++ b/packages/cli/src/__tests__/installer.test.ts @@ -108,7 +108,7 @@ describe('EQLInstaller', () => { databaseUrl: 'postgresql://localhost:5432/test', }) - const result = await installer.isInstalled() + const result = await installer.isInstalled({ eqlVersion: 2 }) expect(result).toBe(true) expect(mockQuery).toHaveBeenCalledWith(expect.any(String), [['eql_v2']]) }) @@ -127,7 +127,7 @@ describe('EQLInstaller', () => { databaseUrl: 'postgresql://localhost:5432/test', }) - await installer.install() + await installer.install({ eqlVersion: 2 }) // Should NOT call fetch — uses bundled SQL expect(fetchSpy).not.toHaveBeenCalled() @@ -160,7 +160,7 @@ describe('EQLInstaller', () => { databaseUrl: 'postgresql://localhost:5432/test', }) - await installer.install({ latest: true }) + await installer.install({ eqlVersion: 2, latest: true }) expect(fetchSpy).toHaveBeenCalledWith( expect.stringContaining('cipherstash-encrypt.sql'), @@ -182,7 +182,7 @@ describe('EQLInstaller', () => { databaseUrl: 'postgresql://localhost:5432/test', }) - await installer.install({ supabase: true }) + await installer.install({ eqlVersion: 2, supabase: true }) // Capture every query string that isn't a transaction control verb. const otherCalls = mockQuery.mock.calls @@ -230,15 +230,41 @@ describe('EQLInstaller', () => { ) expect(otherCalls).toHaveLength(2) - // The bundled SQL is the v3 Supabase variant: creates eql_v3, no - // operator classes/families (they need superuser). + // Since eql-3.0.0 there is ONE v3 bundle for every target: the + // operator-class statements run inside a DO block that self-skips on + // insufficient_privilege, and the bundle disables the ORE-backed + // domains when the opclass is absent (CIP-3468). The supabase install + // therefore executes the SAME artifact as the direct install. expect(otherCalls[0]).toContain('eql_v3') - expect(otherCalls[0]).not.toContain('CREATE OPERATOR CLASS') - expect(otherCalls[0]).not.toContain('CREATE OPERATOR FAMILY') - // The grants are keyed to eql_v3, not eql_v2. + expect(otherCalls[0]).toContain('CREATE OPERATOR CLASS') + expect(otherCalls[0]).toContain('insufficient_privilege') + // The grants are keyed to eql_v3, not eql_v2. The installed block must be + // the SAME string the Supabase migration file embeds — the installer used + // to rebuild it from the schema name alone, letting the two drift. expect(otherCalls[1]).toBe(SUPABASE_PERMISSIONS_SQL_V3) expect(SUPABASE_PERMISSIONS_SQL_V3).toContain('eql_v3') expect(SUPABASE_PERMISSIONS_SQL_V3).not.toContain('eql_v2') + + // `eql_v3.eq_term`/`ord_term`/`match_term` are SECURITY INVOKER and + // qualify `eql_v3_internal.*` in their bodies, so without USAGE on that + // schema every encrypted filter fails for anon/authenticated with + // "permission denied for schema eql_v3_internal". See + // `supabaseInternalPermissionsSql`, and the live proof in + // packages/stack/__tests__/supabase-v3-grants-pg.test.ts. + expect(SUPABASE_PERMISSIONS_SQL_V3).toContain( + 'GRANT USAGE ON SCHEMA eql_v3_internal TO anon, authenticated, service_role;', + ) + expect(SUPABASE_PERMISSIONS_SQL_V3).toContain( + 'GRANT EXECUTE ON ALL ROUTINES IN SCHEMA eql_v3_internal TO anon, authenticated, service_role;', + ) + }) + + // `eql_v2` has no internal schema; the v3-only addition must not leak into + // the v2 block, where it would fail with "schema does not exist". + it('does not grant an internal schema in the v2 permissions block', async () => { + const { SUPABASE_PERMISSIONS_SQL } = await import('@/installer/index.ts') + + expect(SUPABASE_PERMISSIONS_SQL).not.toContain('_internal') }) it('installs the full v3 bundle (with operator classes) without supabase', async () => { diff --git a/packages/cli/src/__tests__/supabase-migration.test.ts b/packages/cli/src/__tests__/supabase-migration.test.ts index a5c0d0958..57b03a1c2 100644 --- a/packages/cli/src/__tests__/supabase-migration.test.ts +++ b/packages/cli/src/__tests__/supabase-migration.test.ts @@ -12,7 +12,11 @@ import { SUPABASE_EQL_MIGRATION_FILENAME, writeSupabaseEqlMigration, } from '../commands/db/supabase-migration.js' -import { SUPABASE_PERMISSIONS_SQL } from '../installer/index.js' +import { + DEFAULT_EQL_VERSION, + resolveEqlVersion, + SUPABASE_PERMISSIONS_SQL, +} from '../installer/index.js' /** * Generate the migration header for testing purposes. @@ -140,8 +144,13 @@ describe('writeSupabaseEqlMigration', () => { /-- CipherStash EQL — installed by `(npx|bunx|pnpm dlx|yarn dlx) stash eql install --supabase --migration`/, ) expect(contents).toContain('CipherStash') - // EQL SQL body — the bundled supabase variant defines eql_v2. - expect(contents).toContain('eql_v2') + // EQL SQL body — the bundled supabase variant defines eql_v2. The + // migration-file flow is v2-only, so the body must be the v2 generation: + // assert the v2 composite type is present and no v3 schema leaks in. (A + // bare `toContain('eql_v2')` isn't enough — the header + permissions + // mention eql_v2 even if the body were v3.) + expect(contents).toContain('eql_v2_encrypted') + expect(contents).not.toContain('eql_v3') // Permissions block (single source of truth). expect(contents).toContain(SUPABASE_PERMISSIONS_SQL.trim()) }) @@ -203,13 +212,33 @@ describe('writeSupabaseEqlMigration', () => { }) }) +describe('resolveEqlVersion', () => { + it('defaults a missing version to DEFAULT_EQL_VERSION (v3)', () => { + expect(DEFAULT_EQL_VERSION).toBe(3) + expect(resolveEqlVersion(undefined)).toBe(3) + }) + + it('resolves explicit strings to their generation', () => { + expect(resolveEqlVersion('2')).toBe(2) + expect(resolveEqlVersion('3')).toBe(3) + }) +}) + describe('validateInstallFlags', () => { it('returns null for an empty options object', () => { expect(validateInstallFlags({})).toBeNull() }) - it('returns null when --supabase is paired with --migration', () => { - expect(validateInstallFlags({ supabase: true, migration: true })).toBeNull() + it('returns null when --supabase + --migration is pinned to --eql-version 2', () => { + // --migration is a v2-only path, so under the v3 default it needs an + // explicit `--eql-version 2` alongside --supabase. + expect( + validateInstallFlags({ + supabase: true, + migration: true, + eqlVersion: '2', + }), + ).toBeNull() }) it('returns null when --supabase is paired with --direct', () => { @@ -255,7 +284,7 @@ describe('validateInstallFlags', () => { expect(validateInstallFlags({ eqlVersion: '4' })).toMatch(/--eql-version/) }) - it('rejects --eql-version 3 with --drizzle, --migration, or --latest', () => { + it('rejects --eql-version 3 with --drizzle, --migration, --latest, or --migrations-dir', () => { expect(validateInstallFlags({ eqlVersion: '3', drizzle: true })).toMatch( /--drizzle/, ) @@ -279,6 +308,36 @@ describe('validateInstallFlags', () => { }), ).toMatch(/--migrations-dir/) }) + + it('defaults to v3: a plain install with no version is valid', () => { + expect(validateInstallFlags({})).toBeNull() + expect(validateInstallFlags({ supabase: true })).toBeNull() + }) + + it('v2-only flags without an explicit --eql-version 2 are rejected under the v3 default', () => { + // No eqlVersion passed → resolves to the v3 default, which can't do these. + for (const opts of [ + { drizzle: true }, + { latest: true }, + { supabase: true, migration: true }, + { supabase: true, migrationsDir: 'db/migrations' }, + ]) { + const err = validateInstallFlags(opts) + expect(err).toMatch(/--eql-version 2/) + } + }) + + it('accepts the v2-only paths when --eql-version 2 is explicit', () => { + expect(validateInstallFlags({ eqlVersion: '2', drizzle: true })).toBeNull() + expect(validateInstallFlags({ eqlVersion: '2', latest: true })).toBeNull() + expect( + validateInstallFlags({ + eqlVersion: '2', + supabase: true, + migration: true, + }), + ).toBeNull() + }) }) describe('routeInstallPathForEqlVersion', () => { diff --git a/packages/cli/src/bin/main.ts b/packages/cli/src/bin/main.ts index 3a0ed5179..c71794a84 100644 --- a/packages/cli/src/bin/main.ts +++ b/packages/cli/src/bin/main.ts @@ -97,8 +97,8 @@ Commands: eql upgrade Upgrade EQL extensions to the latest version eql status Show EQL installation status - db push Push encryption schema (writes pending if active config already exists) - db activate Promote pending → active without renames (use after additive db push) + db push (EQL v2 + Proxy) Push encryption schema to eql_v2_configuration + db activate (EQL v2 + Proxy) Promote pending → active without renames db validate Validate encryption schema db migrate Run pending encrypt config migrations db test-connection Test database connectivity @@ -124,7 +124,6 @@ Examples: ${STASH} init # set up CipherStash in this project ${STASH} auth login # authenticate ${STASH} eql install # install EQL extensions - ${STASH} db push # push encryption schema ${STASH} manifest --json # structured command surface for docs / agents `.trim() diff --git a/packages/cli/src/cli/__tests__/help.test.ts b/packages/cli/src/cli/__tests__/help.test.ts index 81bacb695..5e737bca5 100644 --- a/packages/cli/src/cli/__tests__/help.test.ts +++ b/packages/cli/src/cli/__tests__/help.test.ts @@ -17,7 +17,7 @@ describe('renderCommandHelp', () => { expect(out).toContain('--force') // Value-taking flag renders its placeholder + default annotation. expect(out).toContain('--eql-version <2|3>') - expect(out).toContain('(default: 2)') + expect(out).toContain('(default: 3)') }) it('surfaces a flag env var alongside its description', () => { diff --git a/packages/cli/src/cli/registry.ts b/packages/cli/src/cli/registry.ts index eb7d3fa9e..c388d5ede 100644 --- a/packages/cli/src/cli/registry.ts +++ b/packages/cli/src/cli/registry.ts @@ -331,12 +331,13 @@ export const registry: CommandGroup[] = [ name: '--eql-version', value: '<2|3>', description: - 'EQL generation to target. v3 is the native eql_v3.* domain schema (direct install only for now).', - default: '2', + 'EQL generation to target. v3 (native eql_v3.* domain schema) is the default; pass `2` for the legacy composite type. --drizzle, --migration, --migrations-dir, and --latest are v2-only and require `--eql-version 2`.', + default: '3', }, { name: '--latest', - description: 'Fetch the latest EQL from GitHub (v2 only).', + description: + 'Fetch the latest EQL from GitHub (v2 only — requires --eql-version 2).', }, { name: '--name', @@ -363,12 +364,14 @@ export const registry: CommandGroup[] = [ { name: '--eql-version', value: '<2|3>', - description: 'EQL generation to target.', - default: '2', + description: + 'EQL generation to target. v3 is the default; pass `2` for the legacy composite type. --latest is v2-only and requires `--eql-version 2`.', + default: '3', }, { name: '--latest', - description: 'Fetch the latest EQL from GitHub (v2 only).', + description: + 'Fetch the latest EQL from GitHub (v2 only — requires --eql-version 2).', }, DATABASE_URL_FLAG, ], diff --git a/packages/cli/src/commands/db/activate.ts b/packages/cli/src/commands/db/activate.ts index 8d9aafd84..86e19af72 100644 --- a/packages/cli/src/commands/db/activate.ts +++ b/packages/cli/src/commands/db/activate.ts @@ -45,7 +45,7 @@ export async function activateCommand( ) if (pending.rows[0]?.exists !== true) { p.log.error( - 'No pending EQL configuration to activate. Run `stash db push` first to register a change.', + 'No pending EQL configuration to activate. This applies to the EQL v2 + CipherStash Proxy config lifecycle — register a pending change before activating.', ) exitCode = 1 return diff --git a/packages/cli/src/commands/db/install.ts b/packages/cli/src/commands/db/install.ts index 9cb013b9b..adcb59545 100644 --- a/packages/cli/src/commands/db/install.ts +++ b/packages/cli/src/commands/db/install.ts @@ -16,6 +16,7 @@ import { downloadEqlSql, EQLInstaller, loadBundledEqlSql, + resolveEqlVersion, } from '@/installer/index.js' import { ensureEncryptionClient } from './client-scaffold.js' import { offerStashConfig } from './config-scaffold.js' @@ -77,9 +78,10 @@ export interface InstallOptions { */ scaffoldConfig?: 'ensure' | 'offer' | 'skip' /** - * EQL generation to install: `'2'` (default, composite `eql_v2_encrypted`) - * or `'3'` (native `eql_v3.*` domain schema). v3 currently supports the - * direct install path only — not `--drizzle`, `--migration`, or `--latest`. + * EQL generation to install: `'3'` (default, native `eql_v3.*` domain + * schema) or `'2'` (composite `eql_v2_encrypted`). v3 currently supports the + * direct install path only — `--drizzle`, `--migration`, `--migrations-dir`, + * and `--latest` require an explicit `'2'`. */ eqlVersion?: string } @@ -204,7 +206,7 @@ export async function installCommand(options: InstallOptions) { // CIP-2985. const resolved = resolveProviderOptions(options, databaseUrl) - const eqlVersion: 2 | 3 = options.eqlVersion === '3' ? 3 : 2 + const eqlVersion: 2 | 3 = resolveEqlVersion(options.eqlVersion) // v3 supports the direct install path only. Explicit --drizzle/--migration // are rejected up-front by validateInstallFlags; auto-DETECTED drizzle or @@ -640,23 +642,10 @@ export function validateInstallFlags(options: InstallOptions): string | null { return `Unknown \`--eql-version ${options.eqlVersion}\`. Supported values: 2, 3.` } - if (options.eqlVersion === '3') { - const incompatible = options.drizzle - ? '--drizzle' - : options.migration - ? '--migration' - : options.latest - ? '--latest' - : // --migrations-dir only feeds the Supabase v2 migration-file path; - // the v3 direct install would silently ignore it — reject instead. - options.migrationsDir !== undefined - ? '--migrations-dir' - : null - if (incompatible) { - return `\`--eql-version 3\` does not support \`${incompatible}\` yet — v3 currently installs via the direct path only.` - } - } - + // `--migration` / `--direct` / `--migrations-dir` require `--supabase`. Check + // this before the version gate below so a bare `--migration` still points at + // the missing `--supabase` (its more fundamental prerequisite) rather than + // the version. const subFlag = options.migration === true ? '--migration' @@ -670,6 +659,29 @@ export function validateInstallFlags(options: InstallOptions): string | null { return `\`${subFlag}\` requires \`--supabase\`. Re-run with \`eql install --supabase ${subFlag}\`.` } + // v3 is the default and installs via the direct path only. The Drizzle / + // Supabase-migration / `--latest` paths are v2-only, so they require an + // explicit `--eql-version 2` — otherwise they'd silently resolve to a v3 + // direct install that ignores what the user asked for. `--migrations-dir` + // only feeds the Supabase v2 migration-file path, so it's in the same bucket. + const resolvedVersion = resolveEqlVersion(options.eqlVersion) + if (resolvedVersion === 3) { + const v2OnlyFlag = options.drizzle + ? '--drizzle' + : options.migration + ? '--migration' + : options.latest + ? '--latest' + : options.migrationsDir !== undefined + ? '--migrations-dir' + : null + if (v2OnlyFlag) { + return options.eqlVersion === '3' + ? `\`--eql-version 3\` does not support \`${v2OnlyFlag}\` yet — v3 currently installs via the direct path only.` + : `\`${v2OnlyFlag}\` requires EQL v2. Re-run with \`--eql-version 2 ${v2OnlyFlag}\` (v3 is the default and installs via the direct path only).` + } + } + return null } diff --git a/packages/cli/src/commands/db/push.ts b/packages/cli/src/commands/db/push.ts index cba093f9b..21602be01 100644 --- a/packages/cli/src/commands/db/push.ts +++ b/packages/cli/src/commands/db/push.ts @@ -83,6 +83,24 @@ export async function pushCommand(options: { await client.connect() s.stop('Connected to Postgres.') + // `db push` writes `public.eql_v2_configuration` — a v2 + CipherStash Proxy + // artifact. EQL v3 has no configuration table (config lives in each + // column's `eql_v3.*` domain type) and nothing reads it, so if the table is + // absent — a v3-only database, or a database with no EQL installed at all — + // there's nothing to push. Check the table directly (one query on the + // connection we already hold) and exit cleanly instead of failing later + // with a raw `relation "public.eql_v2_configuration" does not exist`. + const tableResult = await client.query<{ reg: string | null }>( + "SELECT to_regclass('public.eql_v2_configuration') AS reg", + ) + if (tableResult.rows[0]?.reg == null) { + p.log.info( + "`stash db push` writes the EQL v2 configuration table, which this database doesn't have. It only applies to EQL v2 with CipherStash Proxy — under EQL v3 (the default) encryption config lives in each column's `eql_v3.*` type, so there's nothing to push. For a v2 + Proxy setup, run `stash eql install --eql-version 2` first.", + ) + p.outro('Nothing to do.') + return + } + s.start('Checking public.eql_v2_configuration state...') const activeResult = await client.query<{ exists: boolean }>( "SELECT EXISTS(SELECT 1 FROM public.eql_v2_configuration WHERE state = 'active') AS exists", diff --git a/packages/cli/src/commands/db/status.ts b/packages/cli/src/commands/db/status.ts index ebde15963..20fe19864 100644 --- a/packages/cli/src/commands/db/status.ts +++ b/packages/cli/src/commands/db/status.ts @@ -29,9 +29,11 @@ export async function statusCommand(options: { databaseUrl?: string } = {}) { let versionV3: string | null try { - installedV2 = await installer.isInstalled() + installedV2 = await installer.isInstalled({ eqlVersion: 2 }) installedV3 = await installer.isInstalled({ eqlVersion: 3 }) - versionV2 = installedV2 ? await installer.getInstalledVersion() : null + versionV2 = installedV2 + ? await installer.getInstalledVersion({ eqlVersion: 2 }) + : null versionV3 = installedV3 ? await installer.getInstalledVersion({ eqlVersion: 3 }) : null @@ -91,7 +93,22 @@ export async function statusCommand(options: { databaseUrl?: string } = {}) { ) } - // 3. Check for active encrypt config (proxy mode) + // 3. Encrypt configuration. + // + // `public.eql_v2_configuration` is a v2 + CipherStash Proxy artifact: the v2 + // install creates it and Proxy reads it. EQL v3 has no configuration table — + // encryption config lives in each column's `eql_v3.*` domain type — so on a + // v3-only install there's nothing to probe. Gate the check on v2 being + // installed; this also removes the old dead-end that told v3-only users to + // run `db push` (which neither creates that table nor applies to v3). + if (!installedV2) { + p.log.info( + "Encrypt config: carried in each column's `eql_v3.*` type (EQL v3 has no Proxy config table).", + ) + p.outro('Status check complete.') + return + } + s.start('Checking encrypt configuration...') const client = new pg.Client({ connectionString: config.databaseUrl }) @@ -110,22 +127,12 @@ export async function statusCommand(options: { databaseUrl?: string } = {}) { `Active encrypt config: yes (${result.rowCount} active ${result.rowCount === 1 ? 'row' : 'rows'})`, ) } else { - p.log.info( - 'Active encrypt config: none (only needed for CipherStash Proxy)', - ) + p.log.info('Active encrypt config: none (only used by CipherStash Proxy)') } } catch (error) { s.stop('Configuration check failed.') - - // The table may not exist if push has never been run — that's fine const message = error instanceof Error ? error.message : String(error) - if (message.includes('does not exist')) { - p.log.info( - `Active encrypt config: table not found (run \`${runnerCommand(pm, 'stash db push')}\` to create it)`, - ) - } else { - p.log.error(`Failed to check encrypt configuration: ${message}`) - } + p.log.error(`Failed to check encrypt configuration: ${message}`) } finally { await client.end() } diff --git a/packages/cli/src/commands/db/supabase-migration.ts b/packages/cli/src/commands/db/supabase-migration.ts index e1400b465..c541a8a7e 100644 --- a/packages/cli/src/commands/db/supabase-migration.ts +++ b/packages/cli/src/commands/db/supabase-migration.ts @@ -99,11 +99,15 @@ export async function writeSupabaseEqlMigration( ) } - // The runtime install always uses `cipherstash-encrypt-supabase.sql` for - // Supabase, which is the no-operator-family variant. We pass both flags so - // intent is explicit and `loadBundledEqlSql` resolves the supabase file - // even if the underlying selection rules ever change. + // The Supabase migration-file flow is v2-only (v3 has no migration-file + // path), so pin `eqlVersion: 2` explicitly — otherwise it would follow the + // v3 default and emit `cipherstash-encrypt-v3-supabase.sql` alongside the v2 + // `SUPABASE_PERMISSIONS_SQL` below, producing a mismatched migration. We also + // pass both supabase/no-operator-family flags so intent is explicit and + // `loadBundledEqlSql` resolves the supabase file even if selection rules ever + // change. const eqlSql = loadBundledEqlSql({ + eqlVersion: 2, supabase: true, excludeOperatorFamily: excludeOperatorFamily || true, }) diff --git a/packages/cli/src/commands/db/upgrade.ts b/packages/cli/src/commands/db/upgrade.ts index 8e5db0426..b62926778 100644 --- a/packages/cli/src/commands/db/upgrade.ts +++ b/packages/cli/src/commands/db/upgrade.ts @@ -1,7 +1,7 @@ import * as p from '@clack/prompts' import { detectPackageManager, runnerCommand } from '@/commands/init/utils.js' import { loadStashConfig } from '@/config/index.js' -import { EQLInstaller } from '@/installer/index.js' +import { EQLInstaller, resolveEqlVersion } from '@/installer/index.js' export async function upgradeCommand(options: { dryRun?: boolean @@ -9,7 +9,7 @@ export async function upgradeCommand(options: { excludeOperatorFamily?: boolean latest?: boolean databaseUrl?: string - /** EQL generation to upgrade: `'2'` (default) or `'3'`. */ + /** EQL generation to upgrade: `'3'` (default) or `'2'`. */ eqlVersion?: string }) { const pm = detectPackageManager() @@ -26,11 +26,15 @@ export async function upgradeCommand(options: { p.outro('Upgrade aborted.') process.exit(1) } - const eqlVersion: 2 | 3 = options.eqlVersion === '3' ? 3 : 2 + const eqlVersion: 2 | 3 = resolveEqlVersion(options.eqlVersion) if (eqlVersion === 3 && options.latest) { + // `--latest` is v2-only (no public v3 release artifacts exist yet). Since + // v3 is the default, tell the user how to reach the v2 latest upgrade. p.log.error( - '`--eql-version 3` does not support `--latest` — no public v3 release artifacts exist yet. Use the bundled upgrade.', + options.eqlVersion === '3' + ? '`--eql-version 3` does not support `--latest` — no public v3 release artifacts exist yet. Use the bundled upgrade.' + : '`--latest` requires EQL v2 — no public v3 release artifacts exist yet. Re-run with `--eql-version 2 --latest`, or drop `--latest` for the bundled v3 upgrade.', ) p.outro('Upgrade aborted.') process.exit(1) diff --git a/packages/cli/src/commands/encrypt/backfill.ts b/packages/cli/src/commands/encrypt/backfill.ts index caa8ab661..84b2ceab8 100644 --- a/packages/cli/src/commands/encrypt/backfill.ts +++ b/packages/cli/src/commands/encrypt/backfill.ts @@ -201,7 +201,7 @@ export async function backfillCommand(options: BackfillCommandOptions) { // time running a backfill that will fail on the first chunk. if (detectedCastAs === 'date' || detectedCastAs === 'timestamp') { p.log.warn( - `Column ${options.table}.${encryptedColumn} declares cast_as: '${detectedCastAs}', which protect-ffi does not currently support for encryption. The backfill will fail with "Cannot convert String to Date". Consider changing the schema to dataType: 'string' (or omitting dataType) and storing ISO date strings instead, then re-running \`stash db push\`.`, + `Column ${options.table}.${encryptedColumn} declares cast_as: '${detectedCastAs}', which protect-ffi does not currently support for encryption. The backfill will fail with "Cannot convert String to Date". Consider changing the schema to dataType: 'string' (or omitting dataType) and storing ISO date strings instead, then re-running the backfill.`, ) const proceed = await p.confirm({ message: 'Continue anyway?', diff --git a/packages/cli/src/commands/encrypt/context.ts b/packages/cli/src/commands/encrypt/context.ts index c9a80ce46..1975e2d96 100644 --- a/packages/cli/src/commands/encrypt/context.ts +++ b/packages/cli/src/commands/encrypt/context.ts @@ -104,11 +104,11 @@ export async function loadEncryptionContext(): Promise { // Second pass: auto-derive EncryptedTable schemas from drizzle pgTable // exports so users don't have to manually export the result of - // extractEncryptionSchema(). Silently no-op if @cipherstash/stack/drizzle + // extractEncryptionSchema(). Silently no-op if @cipherstash/stack-drizzle // isn't installed (e.g. a Supabase-only project). if (drizzleCandidates.length > 0) { try { - const drizzleModule = (await import('@cipherstash/stack/drizzle')) as { + const drizzleModule = (await import('@cipherstash/stack-drizzle')) as { extractEncryptionSchema?: (t: unknown) => EncryptedTableLike } const extract = drizzleModule.extractEncryptionSchema @@ -127,7 +127,7 @@ export async function loadEncryptionContext(): Promise { } } } catch { - // @cipherstash/stack/drizzle not installed; skip drizzle fallback. + // @cipherstash/stack-drizzle not installed; skip drizzle fallback. } } diff --git a/packages/cli/src/commands/encrypt/cutover.ts b/packages/cli/src/commands/encrypt/cutover.ts index d70ce759d..3d8d4c816 100644 --- a/packages/cli/src/commands/encrypt/cutover.ts +++ b/packages/cli/src/commands/encrypt/cutover.ts @@ -81,7 +81,7 @@ export async function cutoverCommand(options: CutoverCommandOptions) { ) if (pending.rows[0]?.exists !== true) { p.log.error( - 'No pending EQL configuration. Update your schema to point at the encrypted column (drop the `_encrypted` suffix), then run `stash db push` to register the pending change before cutting over.', + 'No pending EQL configuration to cut over. Cutover operates on the EQL v2 + CipherStash Proxy config lifecycle — update your schema to point at the encrypted column (drop the `_encrypted` suffix) and register the pending change before cutting over.', ) exitCode = 1 return diff --git a/packages/cli/src/commands/encrypt/status.ts b/packages/cli/src/commands/encrypt/status.ts index cd75ffc63..8591fbbbb 100644 --- a/packages/cli/src/commands/encrypt/status.ts +++ b/packages/cli/src/commands/encrypt/status.ts @@ -93,7 +93,7 @@ export async function statusCommand() { if (rows.length === 0) { p.log.info( - 'No encrypted columns yet. Run `stash db push` to register columns with EQL, then `stash encrypt backfill --table --column ` once your application is dual-writing.', + 'No encrypted columns yet. Declare an encrypted column in your schema and run the migration, then `stash encrypt backfill --table --column ` once your application is dual-writing.', ) p.outro('Nothing to show.') return diff --git a/packages/cli/src/commands/init/lib/__tests__/setup-prompt.test.ts b/packages/cli/src/commands/init/lib/__tests__/setup-prompt.test.ts index d44f760df..815c7f71a 100644 --- a/packages/cli/src/commands/init/lib/__tests__/setup-prompt.test.ts +++ b/packages/cli/src/commands/init/lib/__tests__/setup-prompt.test.ts @@ -12,7 +12,6 @@ const baseCtx: SetupPromptContext = { handoff: 'claude-code', mode: 'implement', installedSkills: ['stash-encryption', 'stash-drizzle', 'stash-cli'], - usesProxy: false, } describe('renderSetupPrompt — orient + route (implement mode)', () => { @@ -203,7 +202,6 @@ describe('renderSetupPrompt — plan mode (rollout, default)', () => { it('explicitly forbids mutating commands during planning', () => { const out = renderSetupPrompt(planCtx) expect(out).toContain('## What you must NOT do') - expect(out).toMatch(/db push/) expect(out).toMatch(/encrypt backfill/) expect(out).toMatch(/encrypt cutover/) expect(out).toMatch(/encrypt drop/) @@ -305,7 +303,7 @@ describe('renderSetupPrompt — plan mode (cutover)', () => { expect(out).toMatch(/path.*"migrate".*for every column/i) }) - it('covers backfill, schema rename + db push, cutover, read path, drop', () => { + it('covers backfill, schema rename, cutover, read path, drop', () => { const out = renderSetupPrompt(planCtx) expect(out).toMatch(/backfill/i) expect(out).toMatch(/cutover/i) @@ -382,180 +380,28 @@ describe('renderSetupPrompt — plan mode default when planStep is unset', () => }) }) -describe('renderSetupPrompt — usesProxy conditional', () => { - describe('implement mode with usesProxy: false (SDK-only)', () => { - it('drops db push step from add-new-column flow', () => { - const out = renderSetupPrompt({ ...baseCtx, usesProxy: false }) - expect(out).not.toMatch(/5\.\s*Register the encryption config/) - // Step 5 should now be the wire-the-column step, not db push - expect(out).toMatch(/5\.\s*Wire the column through/) - }) - - it('drops register-pending-config step from rollout path', () => { - const out = renderSetupPrompt({ ...baseCtx, usesProxy: false }) - // Should have only "Schema-add" as step 1, then "Dual-write" as step 2 - // (no "Register pending config" in between) - expect(out).toMatch(/1\.\s*\*\*Schema-add/) - expect(out).toMatch(/2\.\s*\*\*Dual-write/) - // Register pending config should not appear in the rollout section - const rolloutSection = out.substring( - out.indexOf('#### Encryption rollout'), - out.indexOf('⛔'), - ) - expect(rolloutSection).not.toMatch(/Register pending config/) - }) - - it('keeps encrypt cutover invocation and notes the pending-config workaround', () => { - const out = renderSetupPrompt({ ...baseCtx, usesProxy: false }) - const cutoverSection = out.substring( - out.indexOf('#### Encryption cutover'), - ) - // Should mention encrypt cutover - expect(cutoverSection).toMatch(/encrypt cutover/) - // SDK-only setups still hit the pending-config gap, so the cutover - // step must call out the `db push` workaround for that error. - expect(cutoverSection).toMatch(/No pending EQL configuration/) - expect(cutoverSection).toMatch(/db push/) - }) - }) - - describe('implement mode with usesProxy: true (Proxy)', () => { - it('includes db push step in add-new-column flow', () => { - const out = renderSetupPrompt({ ...baseCtx, usesProxy: true }) - expect(out).toMatch(/5\.\s*Register the encryption config.*db push/) - expect(out).toMatch(/6\.\s*\*\*If db push wrote pending\*\*.*db activate/) - }) - - it('includes register-pending-config step in rollout path', () => { - const out = renderSetupPrompt({ ...baseCtx, usesProxy: true }) - expect(out).toMatch(/2\.\s*\*\*Register pending config.*db push/) - expect(out).toMatch(/3\.\s*\*\*Dual-write/) - }) - - it('includes full db push in cutover step', () => { - const out = renderSetupPrompt({ ...baseCtx, usesProxy: true }) - const cutoverSection = out.substring( - out.indexOf('#### Encryption cutover'), - ) - expect(cutoverSection).toMatch(/5\.\s*\*\*Switch the schema and re-push/) - expect(cutoverSection).toMatch(/Run.*db push.*again/) - }) - }) - - describe('plan mode (rollout) with usesProxy conditional', () => { - it('mentions db push in rollout plan summary when usesProxy: true', () => { - const out = renderSetupPrompt({ - ...baseCtx, - mode: 'plan', - planStep: 'rollout', - usesProxy: true, - }) - expect(out).toMatch( - /Encryption rollout.*dual-write code, and.*db push.*writes pending/, - ) - }) - - it('notes db push as Proxy-only in rollout plan summary when usesProxy: false', () => { - const out = renderSetupPrompt({ - ...baseCtx, - mode: 'plan', - planStep: 'rollout', - usesProxy: false, - }) - expect(out).toMatch( - /Encryption rollout.*dual-write code.*plus.*db push.*Proxy users only/, - ) - }) - - it('includes db push in rollout PR contents when usesProxy: true', () => { - const out = renderSetupPrompt({ - ...baseCtx, - mode: 'plan', - planStep: 'rollout', - usesProxy: true, - }) - expect(out).toMatch(/schema-add.*db push.*pending.*dual-write code/) - }) - - it('drops db push from rollout PR contents when usesProxy: false', () => { - const out = renderSetupPrompt({ - ...baseCtx, - mode: 'plan', - planStep: 'rollout', - usesProxy: false, - }) - expect(out).toMatch(/schema-add.*dual-write code/) - // Should not mention "db push (pending)" in the rollout PR contents - const prSection = out.substring( - out.indexOf('migrate columns: what the rollout PR contains'), - ) - expect(prSection).not.toMatch(/db push.*pending/) - }) - }) - - describe('plan mode (cutover) with usesProxy conditional', () => { - it('includes db push in schema-rename when usesProxy: true', () => { - const out = renderSetupPrompt({ - ...baseCtx, - mode: 'plan', - planStep: 'cutover', - usesProxy: true, - }) - expect(out).toMatch(/Schema rename and re-push/) - expect(out).toMatch(/db push.*registers the renamed/) - }) - - it('separates schema rename from db push when usesProxy: false', () => { - const out = renderSetupPrompt({ - ...baseCtx, - mode: 'plan', - planStep: 'cutover', - usesProxy: false, - }) - expect(out).toMatch(/\*\*Schema rename\.\*\*.*original column/) - expect(out).toMatch(/Proxy users only.*db push/) - }) - - it('notes db push as Proxy-only in prose when usesProxy: false', () => { - const out = renderSetupPrompt({ - ...baseCtx, - mode: 'plan', - planStep: 'cutover', - usesProxy: false, - }) - expect(out).toMatch(/schema-edit step.*exact rename pattern/) - expect(out).not.toMatch(/schema-edit.*db push.*step/i) - }) - }) - - describe('plan mode (complete) with usesProxy conditional', () => { - it('includes db push steps in full lifecycle when usesProxy: true', () => { - const out = renderSetupPrompt({ - ...baseCtx, - mode: 'plan', - planStep: 'complete', - usesProxy: true, - }) - expect(out).toMatch(/db push.*backfill.*schema rename.*db push.*cutover/) - }) - - it('drops both db push mentions from full lifecycle when usesProxy: false', () => { - const out = renderSetupPrompt({ - ...baseCtx, - mode: 'plan', - planStep: 'complete', - usesProxy: false, - }) - expect(out).toMatch( - /schema-add.*dual-write code.*backfill.*schema rename/, - ) - // The lifecycle line should not have "db push" twice - const migrateSection = out.substring( - out.indexOf('**Migrate existing columns**'), - ) - const firstLine = migrateSection.split('\n')[0] - const dbPushCount = (firstLine.match(/db push/g) || []).length - expect(dbPushCount).toBe(0) - }) +describe('renderSetupPrompt — no db push recommendations', () => { + // `db push` / `eql_v2_configuration` is a v2 + CipherStash Proxy artifact and + // is redundant under EQL v3 (the default). The setup prompt no longer steers + // the agent toward it in any mode. + it('omits db push from the add-new-column and cutover flows (implement mode)', () => { + const out = renderSetupPrompt(baseCtx) + expect(out).not.toMatch(/db push/) + expect(out).not.toMatch(/Register the encryption config/) + // The add-new-column flow goes straight from apply → wire the column. + expect(out).toMatch(/5\.\s*Wire the column through/) + // The rollout path is schema-add → dual-write, with no push step between. + expect(out).toMatch(/1\.\s*\*\*Schema-add/) + expect(out).toMatch(/2\.\s*\*\*Dual-write/) + // Cutover is still covered, just without a db push workaround note. + const cutoverSection = out.substring(out.indexOf('#### Encryption cutover')) + expect(cutoverSection).toMatch(/encrypt cutover/) + }) + + it('omits db push from every plan-mode template', () => { + for (const planStep of ['rollout', 'cutover', 'complete'] as const) { + const out = renderSetupPrompt({ ...baseCtx, mode: 'plan', planStep }) + expect(out).not.toMatch(/db push/) + } }) }) diff --git a/packages/cli/src/commands/init/lib/setup-prompt.ts b/packages/cli/src/commands/init/lib/setup-prompt.ts index 73dec4d01..b278bdd0e 100644 --- a/packages/cli/src/commands/init/lib/setup-prompt.ts +++ b/packages/cli/src/commands/init/lib/setup-prompt.ts @@ -32,8 +32,6 @@ export interface SetupPromptContext { * to `'rollout'` when plan mode is invoked without explicit state — that * matches a fresh project where there are no recorded events yet. */ planStep?: PlanStep - /** Whether the user runs CipherStash Proxy. False = SDK-only (no `stash db push` in default flows). True = prompts include push steps. Captured in stash init; persisted to .cipherstash/context.json. */ - usesProxy: boolean } interface MigrationCommands { @@ -249,17 +247,8 @@ export function renderImplementPrompt(ctx: SetupPromptContext): string { "2. Edit the user's real schema file (`src/db/schema.ts` or wherever they keep it) to declare the new encrypted column. Use the patterns in the integration skill — `encryptedType` for Drizzle, `encryptedColumn` for Supabase. Encrypted columns must be **nullable `jsonb`** at creation time. Never `.notNull()`.", `3. Generate the schema migration${migration ? ` — \`${migration.generate}\` (${migration.tool})` : " using the project's existing migration tooling"}.`, `4. Show the user the generated SQL before applying${migration ? ` — \`${migration.apply}\`` : ''}.`, - ...(ctx.usesProxy - ? [ - `5. Register the encryption config — \`${cli} db push\`. If the project has no active EQL config yet (first encrypted column ever), this writes directly to active and you can skip step 6. If an active config already exists, push writes \`pending\` and prints a next-step note.`, - `6. **If db push wrote pending**, promote it to active — \`${cli} db activate\`. (Use \`${cli} db activate\` here because no rename is needed; \`${cli} encrypt cutover\` is reserved for the migrate-existing-column flow.)`, - '7. Wire the column through the application code: insert paths encrypt before write, select paths decrypt after read, query paths use the right operator (`protectOps.eq`, etc. — see the integration skill).', - '8. Verify with a round-trip: insert a record, select it back, confirm the value decrypts and the search ops work.', - ] - : [ - '5. Wire the column through the application code: insert paths encrypt before write, select paths decrypt after read, query paths use the right operator (`protectOps.eq`, etc. — see the integration skill).', - '6. Verify with a round-trip: insert a record, select it back, confirm the value decrypts and the search ops work.', - ]), + '5. Wire the column through the application code: insert paths encrypt before write, select paths decrypt after read, query paths use the right operator (`protectOps.eq`, etc. — see the integration skill).', + '6. Verify with a round-trip: insert a record, select it back, confirm the value decrypts and the search ops work.', '', '### Migrate an existing column to encrypted', '', @@ -270,14 +259,7 @@ export function renderImplementPrompt(ctx: SetupPromptContext): string { '#### Encryption rollout — what lands before the deploy', '', `1. **Schema-add.** Add a \`_encrypted\` twin column (nullable \`jsonb\`) alongside the existing plaintext column in the user's real schema file. Generate and apply the schema migration. **If this is the first encrypted column in the project, configure the bundler exclusion now** — see the snippets in the previous section. Without it, importing the encryption client at backfill time will crash.`, - ...(ctx.usesProxy - ? [ - `2. **Register pending config** — \`${cli} db push\`. With an existing active config, this writes the new column-set as \`pending\`. Cutover (later) will promote it. (If this is the very first push for the project, db push writes active directly — fine, the rest of the flow still works.)`, - `3. **Dual-write.** Edit the application code so **every persistence path that mutates this row writes both \`\` (plaintext, unchanged) and \`_encrypted\` (ciphertext via the encryption client) — in the same transaction, on every code branch, with no exceptions.** A single missed branch causes silent migration drift later. Reads still come from the plaintext column.`, - ] - : [ - `2. **Dual-write.** Edit the application code so **every persistence path that mutates this row writes both \`\` (plaintext, unchanged) and \`_encrypted\` (ciphertext via the encryption client) — in the same transaction, on every code branch, with no exceptions.** A single missed branch causes silent migration drift later. Reads still come from the plaintext column.`, - ]), + `2. **Dual-write.** Edit the application code so **every persistence path that mutates this row writes both \`\` (plaintext, unchanged) and \`_encrypted\` (ciphertext via the encryption client) — in the same transaction, on every code branch, with no exceptions.** A single missed branch causes silent migration drift later. Reads still come from the plaintext column.`, '', `⛔ **Deploy gate.** Stop here. The application must be running this code in production — the deployed environment that owns the database — before backfill is safe to run. "Live on the user's laptop" or "live in CI" does not count. After the user deploys, tell them to run`, '', @@ -287,21 +269,11 @@ export function renderImplementPrompt(ctx: SetupPromptContext): string { '', '#### Encryption cutover — after dual-writes are live', '', - ...(ctx.usesProxy - ? [ - `4. **Backfill.** Run \`${cli} encrypt backfill --table --column \`. The CLI prompts the user (or accepts \`--confirm-dual-writes-deployed\` non-interactively) to confirm dual-writes are live, then chunks through the existing rows. Resumable; checkpoints to \`cs_migrations\` after every chunk. SIGINT-safe.`, - `5. **Switch the schema and re-push, then cutover.** Update the schema file to declare the encrypted column under its final name (drop \`_encrypted\` suffix, switch \`\` to \`encryptedType\`). Run \`${cli} db push\` again — pending now reflects the renamed shape. Then \`${cli} encrypt cutover --table --column \` runs the rename in one transaction (\`\` → \`_plaintext\`, \`_encrypted\` → \`\`) and promotes pending → active.`, - '6. **Wire the read path through the encryption client.** Post-cutover, `` holds ciphertext. Read code paths must decrypt before returning the value to callers — `decryptModel(row, table)` for Drizzle, the `encryptedSupabase` wrapper for Supabase, or the equivalent `decrypt`/`bulkDecryptModels` calls. Without this step, your read paths return raw `eql_v2_encrypted` payloads to end users. The integration skill has the exact API.', - '7. **Remove the dual-write code.** The plaintext column is now `_plaintext` and is no longer authoritative. Delete the dual-write logic from the persistence layer.', - `8. **Drop.** Run \`${cli} encrypt drop --table --column \`. Generates a migration that removes the now-unused \`_plaintext\`. Apply with the project's normal migration tooling.`, - ] - : [ - `3. **Backfill.** Run \`${cli} encrypt backfill --table --column \`. The CLI prompts the user (or accepts \`--confirm-dual-writes-deployed\` non-interactively) to confirm dual-writes are live, then chunks through the existing rows. Resumable; checkpoints to \`cs_migrations\` after every chunk. SIGINT-safe.`, - `4. **Switch the schema, then cutover.** Update the schema file to declare the encrypted column under its final name (drop \`_encrypted\` suffix, switch \`\` to \`encryptedType\`). Then \`${cli} encrypt cutover --table --column \` runs the rename in one transaction (\`\` → \`_plaintext\`, \`_encrypted\` → \`\`) and promotes pending → active. *Known gap: cutover currently needs a pending EQL config. If it fails with "No pending EQL configuration", run \`${cli} db push\` once before cutover to register the pending change — this applies even on SDK-only setups that otherwise never need \`db push\`.*`, - '5. **Wire the read path through the encryption client.** Post-cutover, `` holds ciphertext. Read code paths must decrypt before returning the value to callers — `decryptModel(row, table)` for Drizzle, the `encryptedSupabase` wrapper for Supabase, or the equivalent `decrypt`/`bulkDecryptModels` calls. Without this step, your read paths return raw `eql_v2_encrypted` payloads to end users. The integration skill has the exact API.', - '6. **Remove the dual-write code.** The plaintext column is now `_plaintext` and is no longer authoritative. Delete the dual-write logic from the persistence layer.', - `7. **Drop.** Run \`${cli} encrypt drop --table --column \`. Generates a migration that removes the now-unused \`_plaintext\`. Apply with the project's normal migration tooling.`, - ]), + `3. **Backfill.** Run \`${cli} encrypt backfill --table --column \`. The CLI prompts the user (or accepts \`--confirm-dual-writes-deployed\` non-interactively) to confirm dual-writes are live, then chunks through the existing rows. Resumable; checkpoints to \`cs_migrations\` after every chunk. SIGINT-safe.`, + `4. **Switch the schema, then cutover.** Update the schema file to declare the encrypted column under its final name (drop \`_encrypted\` suffix, switch \`\` to \`encryptedType\`). Then \`${cli} encrypt cutover --table --column \` runs the rename in one transaction (\`\` → \`_plaintext\`, \`_encrypted\` → \`\`).`, + '5. **Wire the read path through the encryption client.** Post-cutover, `` holds ciphertext. Read code paths must decrypt before returning the value to callers — `decryptModel(row, table)` for Drizzle, the `encryptedSupabase` wrapper for Supabase, or the equivalent `decrypt`/`bulkDecryptModels` calls. Without this step, your read paths return raw encrypted payloads to end users. The integration skill has the exact API.', + '6. **Remove the dual-write code.** The plaintext column is now `_plaintext` and is no longer authoritative. Delete the dual-write logic from the persistence layer.', + `7. **Drop.** Run \`${cli} encrypt drop --table --column \`. Generates a migration that removes the now-unused \`_plaintext\`. Apply with the project's normal migration tooling.`, '', 'Recovery: if the user reports that backfill ran *before* the dual-write code was actually live, drift is expected (rows written during the backfill window land in plaintext only). Re-run with `--force` to encrypt every plaintext row regardless of current state.', '', @@ -339,13 +311,13 @@ export function renderImplementPrompt(ctx: SetupPromptContext): string { * Render the planning action prompt. * * Plan-mode tells the agent its task is to produce a reviewable plan file - * at `.cipherstash/plan.md` — no schema edits, no migrations, no `db push`, - * no `encrypt *` mutations during this phase. Read-only inspection + * at `.cipherstash/plan.md` — no schema edits, no migrations, no + * `encrypt *` mutations during this phase. Read-only inspection * (`stash status`, `stash eql status`, schema grep, file reads) is fine. * * Dispatches by `ctx.planStep`: * - * `'rollout'` (default) — schema-add + dual-write code + db push. + * `'rollout'` (default) — schema-add + dual-write code. * Plan stops at the deploy gate. * `'cutover'` — backfill + cutover + drop. Pre-condition: * `dual_writing` recorded for the targeted @@ -407,7 +379,7 @@ function planSharedNotDoBlock(ctx: SetupPromptContext): string[] { 'Edit schema files, application code, or migration files. The plan describes future changes — it does not perform them.', ), bullet( - `Run \`${cli} db push\`, \`${cli} encrypt backfill\`, \`${cli} encrypt cutover\`, \`${cli} encrypt drop\`, \`${cli} db activate\`, or any other state-mutating command.`, + `Run \`${cli} encrypt backfill\`, \`${cli} encrypt cutover\`, \`${cli} encrypt drop\`, or any other state-mutating command.`, ), bullet( 'Run schema migrations (`drizzle-kit migrate`, `supabase migration up`, `prisma migrate`, etc.).', @@ -478,9 +450,7 @@ function renderRolloutPlanPrompt(ctx: SetupPromptContext): string { '**Add a new encrypted column** — single deploy, no rollout/cutover split. Declared encrypted from the start.', ), bullet( - ctx.usesProxy - ? '**Encryption rollout for an existing column** — the encrypted twin column, the application-side dual-write code, and `stash db push` (writes pending). All of this lands in one PR; the user deploys it; `cs_migrations` records `dual_writing` the next time backfill is invoked.' - : '**Encryption rollout for an existing column** — the encrypted twin column and the application-side dual-write code (plus `stash db push` for Proxy users only). All of this lands in one PR; the user deploys it; `cs_migrations` records `dual_writing` the next time backfill is invoked.', + '**Encryption rollout for an existing column** — the encrypted twin column and the application-side dual-write code. All of this lands in one PR; the user deploys it; `cs_migrations` records `dual_writing` the next time backfill is invoked.', ), '', 'Converting a populated column in place is **not** supported — any "just swap the type" approach corrupts data. If the user asks for that, the plan must explain why and route them to the encryption-rollout flow.', @@ -506,9 +476,7 @@ function renderRolloutPlanPrompt(ctx: SetupPromptContext): string { 'Which path applies per column (additive new column or encryption-rollout for an existing one). Justify briefly.', ), bullet( - ctx.usesProxy - ? 'For migrate columns: what the rollout PR contains — schema-add, `db push` (pending), and the exact dual-write code change. The dual-write definition matters: every persistence path that mutates the row writes both columns, in the same transaction, on every code branch.' - : 'For migrate columns: what the rollout PR contains — schema-add and the exact dual-write code change. The dual-write definition matters: every persistence path that mutates the row writes both columns, in the same transaction, on every code branch.', + 'For migrate columns: what the rollout PR contains — schema-add and the exact dual-write code change. The dual-write definition matters: every persistence path that mutates the row writes both columns, in the same transaction, on every code branch.', ), bullet( `Project-specific risks. Common ones: bundler exclusion not yet configured (Next.js / webpack / Vite), top-level-await in the placeholder encryption client breaks non-Next contexts, existing partial CipherStash state (run \`${cli} eql status\` and note any pre-existing encrypted columns or pending configs).`, @@ -550,7 +518,7 @@ function renderCutoverPlanPrompt(ctx: SetupPromptContext): string { ), `\`${cli} plan\` detected that dual-writes are recorded as live in \`cs_migrations\` for at least one column. Your job is to produce a reviewable plan at \`${PLAN_REL_PATH}\` covering the **encryption cutover** — backfilling historical rows, switching reads through the encryption client, and dropping the old plaintext column. **Do not** make code or schema changes here; do not run mutating CLI commands. Read-only inspection is encouraged.`, '', - 'The encryption rollout (schema-add + dual-write code + `db push`) is assumed already deployed to production. If the prose ends up describing dual-write code edits, you are off-scope — re-anchor on what cutover-step work remains.', + 'The encryption rollout (schema-add + dual-write code) is assumed already deployed to production. If the prose ends up describing dual-write code edits, you are off-scope — re-anchor on what cutover-step work remains.', '', ...planSharedSetupBlock(ctx), '## What this plan covers', @@ -561,19 +529,10 @@ function renderCutoverPlanPrompt(ctx: SetupPromptContext): string { '**Backfill.** Encrypt the historical rows that pre-date the rollout deploy. Resumable; chunked; SIGINT-safe.', ), bullet( - ctx.usesProxy - ? '**Schema rename and re-push.** Update the schema declaration to put the encrypted form under its final column name; `stash db push` registers the renamed pending config.' - : '**Schema rename.** Update the schema declaration so the original column points at the encrypted type.', + '**Schema rename.** Update the schema declaration so the original column points at the encrypted type.', ), - ...(ctx.usesProxy - ? [] - : [ - bullet( - '*Proxy users only*: after the schema rename, also run `stash db push` to register the renamed pending config.', - ), - ]), bullet( - '**Cutover.** A single transaction renames `` → `_plaintext`, `_encrypted` → ``, and promotes the pending EQL config to active.', + '**Cutover.** A single transaction renames `` → `_plaintext` and `_encrypted` → ``.', ), bullet( '**Read path.** Application reads of `` now return ciphertext until the read path decrypts via the encryption client. The plan must specify what changes per read site.', @@ -605,9 +564,7 @@ function renderCutoverPlanPrompt(ctx: SetupPromptContext): string { ' encrypt backfill` invocation with concrete `--table` / `--column` values.', ), bullet( - ctx.usesProxy - ? 'The schema-edit + `db push` step, with the exact rename pattern (drop `_encrypted` suffix on the encrypted column, switch the original column declaration off `text`/`varchar` and onto the encrypted type).' - : 'The schema-edit step, with the exact rename pattern (drop `_encrypted` suffix on the encrypted column, switch the original column declaration off `text`/`varchar` and onto the encrypted type).', + 'The schema-edit step, with the exact rename pattern (drop `_encrypted` suffix on the encrypted column, switch the original column declaration off `text`/`varchar` and onto the encrypted type).', ), bullet( 'The cutover invocation per column: `' + @@ -669,9 +626,7 @@ function renderCompletePlanPrompt(ctx: SetupPromptContext): string { '**Add new encrypted columns** — declared encrypted from the start; single-deploy.', ), bullet( - ctx.usesProxy - ? '**Migrate existing columns** — schema-add → dual-write code → `db push` → backfill → schema rename → `db push` → cutover → read-path switch → remove dual-write code → drop plaintext. No deploy gate between rollout and cutover steps because there is no deployed application to gate on.' - : '**Migrate existing columns** — schema-add → dual-write code → backfill → schema rename → cutover → read-path switch → remove dual-write code → drop plaintext. No deploy gate between rollout and cutover steps because there is no deployed application to gate on.', + '**Migrate existing columns** — schema-add → dual-write code → backfill → schema rename → cutover → read-path switch → remove dual-write code → drop plaintext. No deploy gate between rollout and cutover steps because there is no deployed application to gate on.', ), '', '## Your task: produce the complete-rollout plan file', diff --git a/packages/cli/src/commands/init/lib/write-context.ts b/packages/cli/src/commands/init/lib/write-context.ts index 7f8b98c4c..66d14e52a 100644 --- a/packages/cli/src/commands/init/lib/write-context.ts +++ b/packages/cli/src/commands/init/lib/write-context.ts @@ -168,7 +168,6 @@ export function buildSetupPromptContext( mode: state.mode ?? 'implement', installedSkills, planStep: state.planStep, - usesProxy: state.usesProxy ?? false, } } diff --git a/packages/cli/src/commands/init/steps/install-deps.ts b/packages/cli/src/commands/init/steps/install-deps.ts index afc6a379c..574ee92ab 100644 --- a/packages/cli/src/commands/init/steps/install-deps.ts +++ b/packages/cli/src/commands/init/steps/install-deps.ts @@ -12,16 +12,41 @@ import { const STACK_PACKAGE = '@cipherstash/stack' const CLI_PACKAGE = 'stash' const PRISMA_NEXT_PACKAGE = '@cipherstash/prisma-next' +const DRIZZLE_PACKAGE = '@cipherstash/stack-drizzle' +const SUPABASE_PACKAGE = '@cipherstash/stack-supabase' + +/** + * The integration adapter is its OWN package (depends on `@cipherstash/stack`), + * not a subpath of it — so whichever integration the user picked, its adapter + * package must be installed too, or the scaffolded client code (which imports + * e.g. `@cipherstash/stack-drizzle`) fails to resolve. + */ +function integrationPackageFor(integration?: string): string | null { + switch (integration) { + case 'prisma-next': + return PRISMA_NEXT_PACKAGE + case 'drizzle': + return DRIZZLE_PACKAGE + case 'supabase': + return SUPABASE_PACKAGE + default: + return null + } +} /** * Install the runtime + dev npm packages the user needs to run encryption: * - * - `@cipherstash/stack` (prod) — the encryption client and per-integration - * helpers (drizzle, supabase, schema). + * - `@cipherstash/stack` (prod) — the encryption client, schema builders, and + * EQL v3 typed client. + * - the integration adapter package (prod), if the chosen integration has one: + * `@cipherstash/stack-drizzle`, `@cipherstash/stack-supabase`, or + * `@cipherstash/prisma-next`. These are separate packages that depend on + * `@cipherstash/stack`. * - `stash` (dev) — the CLI itself, so the user can run `stash eql install`, * `stash wizard`, etc. as a project script without the global install. * - * Skips silently when both are already present. Prompts before running the + * Skips silently when everything is already present. Prompts before running the * install commands so the user sees the package manager invocation that's * about to execute. */ @@ -29,18 +54,19 @@ export const installDepsStep: InitStep = { id: 'install-deps', name: 'Install dependencies', async run(state: InitState, provider: InitProvider): Promise { - const wantPrismaNext = - state.integration === 'prisma-next' || provider.name === 'prisma-next' + const integrationPkg = + integrationPackageFor(state.integration) ?? + integrationPackageFor(provider.name) const stackPresent = isPackageInstalled(STACK_PACKAGE) const cliPresent = isPackageInstalled(CLI_PACKAGE) - const prismaNextPresent = wantPrismaNext - ? isPackageInstalled(PRISMA_NEXT_PACKAGE) + const integrationPresent = integrationPkg + ? isPackageInstalled(integrationPkg) : true // Everything already there — silent success, no prompts. - if (stackPresent && cliPresent && prismaNextPresent) { - const installed = wantPrismaNext - ? `${STACK_PACKAGE}, ${PRISMA_NEXT_PACKAGE} and ${CLI_PACKAGE}` + if (stackPresent && cliPresent && integrationPresent) { + const installed = integrationPkg + ? `${STACK_PACKAGE}, ${integrationPkg} and ${CLI_PACKAGE}` : `${STACK_PACKAGE} and ${CLI_PACKAGE}` p.log.success(`${installed} are already installed.`) return { ...state, stackInstalled: true, cliInstalled: true } @@ -49,8 +75,7 @@ export const installDepsStep: InitStep = { const pm = detectPackageManager() const prodPackages: string[] = [] if (!stackPresent) prodPackages.push(STACK_PACKAGE) - if (wantPrismaNext && !prismaNextPresent) - prodPackages.push(PRISMA_NEXT_PACKAGE) + if (integrationPkg && !integrationPresent) prodPackages.push(integrationPkg) const devPackages = cliPresent ? [] : [CLI_PACKAGE] const commands = combinedInstallCommands(pm, prodPackages, devPackages) @@ -109,12 +134,18 @@ export const installDepsStep: InitStep = { // per-package tracking, not a composite flag. const stackInstalled = isPackageInstalled(STACK_PACKAGE) const cliInstalled = isPackageInstalled(CLI_PACKAGE) + const integrationInstalled = integrationPkg + ? isPackageInstalled(integrationPkg) + : true - if (stackInstalled && cliInstalled) { + if (stackInstalled && cliInstalled && integrationInstalled) { p.log.success('Stack dependencies installed.') } else { const stillMissing = [ ...(stackInstalled ? [] : [`${STACK_PACKAGE} (prod)`]), + ...(integrationPkg && !integrationInstalled + ? [`${integrationPkg} (prod)`] + : []), ...(cliInstalled ? [] : [`${CLI_PACKAGE} (dev)`]), ] p.log.warn(`Still missing: ${stillMissing.join(', ')}.`) diff --git a/packages/cli/src/commands/init/steps/install-eql.ts b/packages/cli/src/commands/init/steps/install-eql.ts index f647d95fd..e17f90e35 100644 --- a/packages/cli/src/commands/init/steps/install-eql.ts +++ b/packages/cli/src/commands/init/steps/install-eql.ts @@ -91,6 +91,11 @@ export const installEqlStep: InitStep = { supabase: supabase || undefined, drizzle: drizzle || undefined, databaseUrl: state.databaseUrl, + // EQL v3 is the default, but the Drizzle migration path is v2-only, so + // pin v2 when we're driving the Drizzle flow — otherwise the install + // would reject `--drizzle` under the v3 default. Supabase and plain + // Postgres projects take the v3 default (direct install). + eqlVersion: drizzle ? '2' : undefined, // init passes a resolved URL to avoid re-prompting, but still wants a // config scaffolded — this is NOT a one-shot `--database-url` run. scaffoldConfig: 'ensure', diff --git a/packages/cli/src/commands/init/utils.ts b/packages/cli/src/commands/init/utils.ts index 7d8e3c4e4..3ccb3a277 100644 --- a/packages/cli/src/commands/init/utils.ts +++ b/packages/cli/src/commands/init/utils.ts @@ -231,7 +231,7 @@ function generateDrizzleFromSchema(schema: SchemaDef): string { }) return `import { pgTable, integer, timestamp } from 'drizzle-orm/pg-core' -import { encryptedType, extractEncryptionSchema } from '@cipherstash/stack/drizzle' +import { encryptedType, extractEncryptionSchema } from '@cipherstash/stack-drizzle' import { Encryption } from '@cipherstash/stack' export const ${varName} = pgTable('${schema.tableName}', { @@ -330,7 +330,7 @@ const ${schemaVarName} = extractEncryptionSchema(${varName})` const schemaVarNames = schemas.map((s) => `${toCamelCase(s.tableName)}Schema`) return `import { pgTable, integer, timestamp } from 'drizzle-orm/pg-core' -import { encryptedType, extractEncryptionSchema } from '@cipherstash/stack/drizzle' +import { encryptedType, extractEncryptionSchema } from '@cipherstash/stack-drizzle' import { Encryption } from '@cipherstash/stack' ${tableDefs.join('\n\n')} @@ -437,7 +437,7 @@ const DRIZZLE_PLACEHOLDER = `/** * * Encrypted twin column for an existing populated column (path 3 — lifecycle): * - * import { encryptedType } from '@cipherstash/stack/drizzle' + * import { encryptedType } from '@cipherstash/stack-drizzle' * * export const users = pgTable('users', { * id: integer('id').primaryKey().generatedAlwaysAsIdentity(), @@ -457,7 +457,7 @@ const DRIZZLE_PLACEHOLDER = `/** * * Once you have encrypted tables declared, harvest them and pass to Encryption(): * - * import { extractEncryptionSchema } from '@cipherstash/stack/drizzle' + * import { extractEncryptionSchema } from '@cipherstash/stack-drizzle' * import { users, orders } from './db/schema' * * export const encryptionClient = await Encryption({ diff --git a/packages/cli/src/commands/status/quest.ts b/packages/cli/src/commands/status/quest.ts index 57811d9f8..0dabf8d34 100644 --- a/packages/cli/src/commands/status/quest.ts +++ b/packages/cli/src/commands/status/quest.ts @@ -221,7 +221,7 @@ function nextMoveFor( ): string { if (path === 'new') { if (doneCount === 0) { - return `Declare the encrypted column in your schema and run the migration, then \`${cli} db push\`.` + return 'Declare the encrypted column in your schema and run the migration.' } return `Promote the pending EQL config — \`${cli} db activate\`.` } diff --git a/packages/cli/src/installer/grants.ts b/packages/cli/src/installer/grants.ts new file mode 100644 index 000000000..ee9ec00af --- /dev/null +++ b/packages/cli/src/installer/grants.ts @@ -0,0 +1,82 @@ +/** + * The Supabase grants blocks, as pure strings. + * + * Deliberately import-free. `installer/index.ts` pulls in `pg` and the EQL SQL + * bundle, which no other package depends on; keeping the grants here lets the + * live proof in `packages/stack/__tests__/supabase-v3-grants-pg.test.ts` assert + * against the EXACT SQL this package ships, without `@cipherstash/stack` taking + * a dependency on `stash` (which would be a cycle — `stash` already depends on + * `@cipherstash/stack`). Re-exported from `installer/index.ts`, which remains + * the public entry point. + */ + +/** EQL v2's operator schema. It has no internal schema. */ +export const EQL_SCHEMA_NAME = 'eql_v2' + +/** + * EQL v3 installs its operator functions into `eql_v3` (constructors live in + * `eql_v3_internal`; the scalar type domains live in `public`). The `eql_v3` + * schema is the install-detection target, and BOTH schemas are grant targets — + * see {@link supabaseInternalPermissionsSql}. + */ +export const EQL_V3_SCHEMA_NAME = 'eql_v3' +export const EQL_V3_INTERNAL_SCHEMA_NAME = 'eql_v3_internal' + +/** + * Build the SQL block that grants an EQL schema, tables, routines, and + * sequences to Supabase's built-in roles (`anon`, `authenticated`, + * `service_role`). + * + * Supabase uses dedicated roles that don't own the schema, so explicit grants + * are required. Returned as a single multi-statement string so it can be + * executed in one `client.query()` (Postgres accepts multi-statement strings) + * AND embedded directly into a Supabase migration file. One source of truth + * for both the runtime install path and the generated migration file, shared + * by the v2 (`eql_v2`) and v3 (`eql_v3`) installs. + */ +export function supabasePermissionsSql(schemaName: string): string { + return `GRANT USAGE ON SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT EXECUTE ON ALL ROUTINES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT USAGE ON ALL SEQUENCES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT SELECT ON TABLES TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; +` +} + +/** + * Grants a *supporting* EQL schema that holds only routines and types — no + * tables or sequences to grant. + * + * Load-bearing for EQL v3. Every public entry point the query path touches + * (`eql_v3.eq_term`, `ord_term`, `match_term` — 68 of their 69 overloads) is + * SECURITY INVOKER and qualifies `eql_v3_internal.*` by name in its body. + * Postgres resolves those names with the CALLER's privileges, and schema USAGE + * is checked at name resolution. Without USAGE on `eql_v3_internal`, `anon` and + * `authenticated` get `permission denied for schema eql_v3_internal` on EVERY + * encrypted filter — `=`, `>=`, and `@>` alike, since each routes through a + * term extractor. The default PUBLIC EXECUTE on functions means USAGE is the + * only real barrier; EXECUTE is granted too so an install into a database that + * has revoked EXECUTE from PUBLIC still works. + * + * `eql_v2` has no internal schema, so this applies to v3 only. + */ +export function supabaseInternalPermissionsSql(schemaName: string): string { + return `GRANT USAGE ON SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT EXECUTE ON ALL ROUTINES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; +` +} + +/** The v2 (`eql_v2`) Supabase grants block. See {@link supabasePermissionsSql}. */ +export const SUPABASE_PERMISSIONS_SQL = supabasePermissionsSql(EQL_SCHEMA_NAME) + +/** + * The v3 Supabase grants block: `eql_v3` (the public surface) AND + * `eql_v3_internal` (which its function bodies reach into). See + * {@link supabaseInternalPermissionsSql} for why the second block is required. + */ +export const SUPABASE_PERMISSIONS_SQL_V3 = + supabasePermissionsSql(EQL_V3_SCHEMA_NAME) + + supabaseInternalPermissionsSql(EQL_V3_INTERNAL_SCHEMA_NAME) diff --git a/packages/cli/src/installer/index.ts b/packages/cli/src/installer/index.ts index 5f8158fff..b5ae91556 100644 --- a/packages/cli/src/installer/index.ts +++ b/packages/cli/src/installer/index.ts @@ -1,66 +1,78 @@ import { existsSync, readFileSync } from 'node:fs' import { dirname, join, resolve } from 'node:path' import pg from 'pg' +import { + EQL_SCHEMA_NAME, + EQL_V3_INTERNAL_SCHEMA_NAME, + EQL_V3_SCHEMA_NAME, + SUPABASE_PERMISSIONS_SQL, + SUPABASE_PERMISSIONS_SQL_V3, +} from './grants.js' // EQL release, pinned to match the EQL payload format this package emits. // Bump in lockstep with @cipherstash/protect-ffi. const EQL_VERSION = 'eql-2.3.1' const EQL_INSTALL_URL = `https://github.com/cipherstash/encrypt-query-language/releases/download/${EQL_VERSION}/cipherstash-encrypt.sql` const EQL_INSTALL_NO_OPERATOR_FAMILY_URL = `https://github.com/cipherstash/encrypt-query-language/releases/download/${EQL_VERSION}/cipherstash-encrypt-supabase.sql` -const EQL_SCHEMA_NAME = 'eql_v2' -const EQL_V3_SCHEMA_NAME = 'eql_v3' -const EQL_V3_INTERNAL_SCHEMA_NAME = 'eql_v3_internal' + +// The grants SQL lives in `./grants.ts` (import-free) so the live proof in +// `@cipherstash/stack` can assert against the exact shipped strings without a +// package cycle. Re-exported here: this module stays the public entry point. +export { + EQL_SCHEMA_NAME, + EQL_V3_INTERNAL_SCHEMA_NAME, + EQL_V3_SCHEMA_NAME, + SUPABASE_PERMISSIONS_SQL, + SUPABASE_PERMISSIONS_SQL_V3, + supabaseInternalPermissionsSql, + supabasePermissionsSql, +} from './grants.js' /** * Which EQL generation to install / inspect. `2` is the composite - * `eql_v2_encrypted` type; `3` is the native `eql_v3.*` domain schema. + * `eql_v2_encrypted` type; `3` is the native concrete-domain schema + * (`public.*` domains, `eql_v3` operators). */ export type EqlVersion = 2 | 3 -function schemaNameFor(eqlVersion: EqlVersion): string { - return eqlVersion === 3 ? EQL_V3_SCHEMA_NAME : EQL_SCHEMA_NAME -} +/** + * The generation `stash eql install` / `eql upgrade` target when the user + * doesn't pass `--eql-version`. v3 (native `eql_v3.*` domain types) is the + * current default; v2 is opt-in via `--eql-version 2` and is required for the + * Drizzle / Supabase-migration / `--latest` paths, which v3 doesn't support + * yet. + */ +export const DEFAULT_EQL_VERSION: EqlVersion = 3 /** - * Build the SQL block that grants an EQL schema, tables, routines, and - * sequences to Supabase's built-in roles (`anon`, `authenticated`, - * `service_role`). - * - * Supabase uses dedicated roles that don't own the schema, so explicit grants - * are required. Returned as a single multi-statement string so it can be - * executed in one `client.query()` (Postgres accepts multi-statement strings) - * AND embedded directly into a Supabase migration file. One source of truth - * for both the runtime install path and the generated migration file, shared - * by the v2 (`eql_v2`) and v3 (`eql_v3`) installs. + * Resolve the `--eql-version` CLI string (`'2'` / `'3'` / `undefined`) to a + * concrete {@link EqlVersion}, applying {@link DEFAULT_EQL_VERSION} for anything + * that isn't an explicit `'2'`. The single authority for "which generation does + * a bare invocation target", shared by `eql install` / `eql upgrade` so the + * default lives in one place rather than being re-inlined as `=== '2' ? 2 : 3`. + * Assumes the value has already been validated (see `validateInstallFlags`). */ -export function supabasePermissionsSql(schemaName: string): string { - return `GRANT USAGE ON SCHEMA ${schemaName} TO anon, authenticated, service_role; -GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; -GRANT EXECUTE ON ALL ROUTINES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; -GRANT USAGE ON ALL SEQUENCES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; -ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT SELECT ON TABLES TO anon, authenticated, service_role; -ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; -ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; -` +export function resolveEqlVersion(eqlVersion?: string): EqlVersion { + return eqlVersion === '2' ? 2 : DEFAULT_EQL_VERSION } -/** The v2 (`eql_v2`) Supabase grants block. See {@link supabasePermissionsSql}. */ -export const SUPABASE_PERMISSIONS_SQL = supabasePermissionsSql(EQL_SCHEMA_NAME) +function schemaNameFor(eqlVersion: EqlVersion): string { + return eqlVersion === 3 ? EQL_V3_SCHEMA_NAME : EQL_SCHEMA_NAME +} /** - * The v3 Supabase grants block: `eql_v3` AND `eql_v3_internal`. The bundle's - * functions are all SECURITY INVOKER (deliberately, so PostgreSQL can inline - * them), and the `eql_v3` operators call into SEM extractors/comparators that - * live in `eql_v3_internal` — so the calling role itself needs USAGE/EXECUTE - * on the internal schema too, or every encrypted query fails `42501`. - * - * Grants ≠ exposure: only `eql_v3` goes in the dashboard's Exposed schemas; - * `eql_v3_internal` must stay unexposed (the split exists so the Supabase - * Table-Builder type picker shows only the column domains). + * The grants block for an EQL generation — the ONE source of truth for both the + * runtime install path ({@link EQLInstaller.grantSupabasePermissions}) and the + * generated Supabase migration file. Previously the installer rebuilt the block + * from `supabasePermissionsSql(schemaNameFor(...))`, so a v3-only addition (the + * `eql_v3_internal` grants) reached the migration file and NOT the database the + * CLI installs into. */ -export const SUPABASE_PERMISSIONS_SQL_V3 = - supabasePermissionsSql(EQL_V3_SCHEMA_NAME) + - supabasePermissionsSql(EQL_V3_INTERNAL_SCHEMA_NAME) +export function supabaseGrantsFor(eqlVersion: EqlVersion): string { + return eqlVersion === 3 + ? SUPABASE_PERMISSIONS_SQL_V3 + : SUPABASE_PERMISSIONS_SQL +} /** * Get the directory of the current file, supporting both ESM and CJS. @@ -200,11 +212,11 @@ export class EQLInstaller { /** * Check whether the EQL extension is installed by looking for its schema - * (`eql_v2` by default, `eql_v3` when `eqlVersion: 3`). + * (`eql_v3` by default, `eql_v2` when `eqlVersion: 2`). */ async isInstalled(options?: { eqlVersion?: EqlVersion }): Promise { const client = new pg.Client({ connectionString: this.databaseUrl }) - const eqlVersion = options?.eqlVersion ?? 2 + const eqlVersion = options?.eqlVersion ?? DEFAULT_EQL_VERSION try { await client.connect() @@ -244,7 +256,7 @@ export class EQLInstaller { async getInstalledVersion(options?: { eqlVersion?: EqlVersion }): Promise { - const schemaName = schemaNameFor(options?.eqlVersion ?? 2) + const schemaName = schemaNameFor(options?.eqlVersion ?? DEFAULT_EQL_VERSION) const client = new pg.Client({ connectionString: this.databaseUrl }) try { @@ -300,12 +312,17 @@ export class EQLInstaller { latest?: boolean eqlVersion?: EqlVersion }): Promise { - const { supabase = false, latest = false, eqlVersion = 2 } = options ?? {} + const { + supabase = false, + latest = false, + eqlVersion = DEFAULT_EQL_VERSION, + } = options ?? {} const excludeOperatorFamily = options?.excludeOperatorFamily || supabase if (latest && eqlVersion === 3) { // No public v3 release artifacts exist yet — the v3 bundles are vendored // from the generated monolith (see scripts/build-eql-v3-sql.mjs). + // Gating --latest behind --eql-version 2 is tracked in #585. throw new Error( '`--latest` is not supported for EQL v3 yet: no public v3 release artifacts exist. Use the bundled install.', ) @@ -358,7 +375,7 @@ export class EQLInstaller { * * Supabase uses dedicated roles (anon, authenticated, service_role) that * don't own the schema, so explicit grants are required. Issues the - * {@link supabasePermissionsSql} block as a single multi-statement query — + * {@link supabaseGrantsFor} block as a single multi-statement query — * Postgres accepts that and it keeps the SQL identical to what we'd write * into a Supabase migration file. */ @@ -366,13 +383,7 @@ export class EQLInstaller { client: pg.Client, eqlVersion: EqlVersion, ): Promise { - // v3 grants cover eql_v3 AND eql_v3_internal (SECURITY INVOKER functions - // in the internal schema back the eql_v3 operators). - await client.query( - eqlVersion === 3 - ? SUPABASE_PERMISSIONS_SQL_V3 - : supabasePermissionsSql(schemaNameFor(eqlVersion)), - ) + await client.query(supabaseGrantsFor(eqlVersion)) } /** @@ -432,18 +443,19 @@ export class EQLInstaller { * - `excludeOperatorFamily: true` → no operator family variant * - default → standard install * - * For EQL v3 the Supabase variant IS the no-operator-family variant (the v3 - * bundle's only superuser-requiring statements are its two operator-class - * chunks), so both flags resolve to the same file. + * EQL v3 (eql-3.0.0+) ships ONE artifact for every target: its only + * superuser-requiring statements (the ore_block_256 operator class/family) + * self-skip on `insufficient_privilege`, and the bundle then disables the + * ORE-backed encrypted domains it cannot support (CIP-3468). So `supabase` + * and `excludeOperatorFamily` change nothing for v3 — the bundle adapts at + * install time instead of at file-selection time. */ function resolveBundledFilename(options: { excludeOperatorFamily: boolean supabase: boolean eqlVersion?: EqlVersion }): string { - if ((options.eqlVersion ?? 2) === 3) { - if (options.supabase || options.excludeOperatorFamily) - return 'cipherstash-encrypt-v3-supabase.sql' + if ((options.eqlVersion ?? DEFAULT_EQL_VERSION) === 3) { return 'cipherstash-encrypt-v3.sql' } if (options.supabase) return 'cipherstash-encrypt-supabase.sql' @@ -465,7 +477,7 @@ export function loadBundledEqlSql( const filename = resolveBundledFilename({ excludeOperatorFamily: options.excludeOperatorFamily ?? false, supabase: options.supabase ?? false, - eqlVersion: options.eqlVersion ?? 2, + eqlVersion: options.eqlVersion ?? DEFAULT_EQL_VERSION, }) try { diff --git a/packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql b/packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql deleted file mode 100644 index 45f11bc8a..000000000 --- a/packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql +++ /dev/null @@ -1,36229 +0,0 @@ ---! @file v3/schema.sql ---! @brief EQL v3 schema creation ---! ---! Creates the eql_v3 and eql_v3_internal schemas. eql_v3 is the public API: ---! the self-contained encrypted-domain type families (eql_v3.integer, eql_v3.bigint, ---! and future scalar domains) — their jsonb-backed domains, index-term ---! extractors, aggregates, AND the operator-backing comparison wrappers ---! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment ---! helpers). The wrappers are public because they are the function-form ---! equivalent of every supported operator: platforms without operator support ---! (Supabase/PostgREST calls functions, not operators) invoke them by name. ---! eql_v3_internal houses INTERNAL implementation objects only: the ---! searchable-encrypted-metadata (SEM) index-term types ---! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support ---! functions, the unsupported-operator blockers (which only raise), and the ---! aggregate state functions. Together the two schemas are self-contained — ---! they own every type they need and have no runtime dependency on another EQL ---! schema. ---! ---! Drops existing schema if present to support clean reinstallation. ---! ---! @warning DROP SCHEMA CASCADE will remove all objects in the schema ---! @note eql_v3 is a new, additional schema for the encrypted-domain families. ---! ---! @note DESIGN DECISION — EQL never grants permissions automatically. This ---! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal: ---! access is strictly opt-in. A deployment that exposes EQL to ---! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST) ---! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on ---! the functions it needs. This is intentional least-privilege, not an ---! oversight — see docs/reference/permissions.md. eql_v3_internal is not ---! part of the public API and normally needs no grant; where a caller ---! reaches an internal object indirectly (a public operator/aggregate ---! whose backing state-fn/blocker lives there), grant it deliberately. - ---! @brief Drop existing EQL v3 schema ---! @warning CASCADE will drop all dependent objects -DROP SCHEMA IF EXISTS eql_v3 CASCADE; - ---! @brief Create EQL v3 schema ---! @note Houses the encrypted-domain type families -CREATE SCHEMA eql_v3; - ---! @brief Drop existing EQL v3 internal schema ---! @warning CASCADE will drop all dependent objects -DROP SCHEMA IF EXISTS eql_v3_internal CASCADE; - ---! @brief Create EQL v3 internal implementation schema ---! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their ---! support/constructor/comparator functions, the unsupported-operator ---! blockers (which only raise), the aggregate state functions, and the ---! SteVec CHECK validators. Kept out of the public `eql_v3` surface so ---! internal index-term TYPES do not clutter the Supabase Table Builder ---! type picker. NOTE: the operator-backing comparison *wrappers* are NOT ---! here — they are public in `eql_v3` so every operator has a callable ---! function equivalent for platforms without operator support. -CREATE SCHEMA eql_v3_internal; -COMMENT ON SCHEMA eql_v3_internal IS - 'EQL internal implementation detail; not a public API surface.'; - ---! @brief Schemas owned by the eql_v3 surface ---! ---! Single source of truth for tooling that must enumerate every schema this ---! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a ---! future third eql_v3-family schema is one array literal to edit instead of ---! a hardcoded schema-name predicate repeated at every call site. Keep in ---! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in ---! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into ---! each schema; this drives what tooling scans across both. ---! ---! @return name[] The schema names eql_v3 owns (public + internal). -CREATE FUNCTION eql_v3_internal.owned_schemas() - RETURNS name[] - LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ - SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[] -$$; - ---! @file v3/crypto.sql ---! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) ---! ---! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency ---! closure lives under src/v3/. Enables the pgcrypto extension which provides ---! cryptographic functions used by the eql_v3 ORE comparison path. ---! ---! Installs pgcrypto into the `extensions` schema (Supabase convention) to ---! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto ---! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing ---! install in `public` keeps working — and a pre-existing install anywhere else ---! will be rejected at install time. The body is idempotent ---! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it ---! alongside the eql_v2 copy in a combined install is safe. ---! ---! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes() - ---! @brief Create extensions schema (Supabase convention) -CREATE SCHEMA IF NOT EXISTS extensions; - ---! @brief Enable pgcrypto extension and validate its schema -DO $$ -DECLARE - pgcrypto_schema name; -BEGIN - IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN - CREATE EXTENSION pgcrypto WITH SCHEMA extensions; - END IF; - - SELECT n.nspname INTO pgcrypto_schema - FROM pg_extension e - JOIN pg_namespace n ON n.oid = e.extnamespace - WHERE e.extname = 'pgcrypto'; - - IF pgcrypto_schema = 'extensions' THEN - -- expected location, nothing to say - NULL; - ELSIF pgcrypto_schema = 'public' THEN - RAISE NOTICE - 'pgcrypto is installed in the `public` schema. EQL works against this layout, ' - 'but Supabase splinter will flag it as `extension_in_public`. Move it with: ' - 'ALTER EXTENSION pgcrypto SET SCHEMA extensions'; - ELSE - RAISE EXCEPTION - 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path ' - '(pg_catalog, extensions, public). EQL cryptographic operations would fail at ' - 'runtime. Relocate the extension before installing EQL: ' - 'ALTER EXTENSION pgcrypto SET SCHEMA extensions', - pgcrypto_schema; - END IF; -END $$; - ---! @file v3/common.sql ---! @brief Common utility functions for the self-contained eql_v3 surface. ---! ---! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the ---! one transitive helper it needs without reaching into another schema. The ---! eql_v2 original is unchanged. - ---! @brief Convert JSONB hex array to bytea array ---! @internal ---! ---! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array. ---! Used for deserializing binary data (like ORE terms) from JSONB storage. ---! ---! @param val jsonb JSONB array of hex-encoded strings ---! @return bytea[] Array of decoded binary values ---! ---! @note Returns NULL if input is JSON null ---! @note Each array element is hex-decoded to bytea ---! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the ---! planner can fold this per-encrypted-value helper into the calling query. ---! This deliberately diverges from the v2 plpgsql equivalent (intentionally ---! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only ---! evaluates the set-returning `jsonb_array_elements_text` for an array, so a ---! non-array JSON scalar returns NULL here instead of raising "cannot extract ---! elements from a scalar". Both callers only ever pass an array or JSON null ---! (`val->'ob'`), so the divergence is unreachable in practice; JSON null and ---! empty array still return NULL exactly as before. -CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb) -RETURNS bytea[] - IMMUTABLE -AS $$ - SELECT CASE WHEN jsonb_typeof(val) = 'array' - THEN ( - SELECT array_agg(decode(value::text, 'hex')::bytea) - FROM jsonb_array_elements_text(val) AS value - ) - ELSE NULL - END; -$$ LANGUAGE sql; - ---! @internal Mark this hand-written helper inline-critical so the post-install ---! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving ---! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed ---! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does ---! not recognise it; this marker is the documented manual opt-in. -COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS - 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; - ---! @file v3/sem/ore_block_256/types.sql ---! @brief ORE block index-term types (eql_v3 SEM). ---! ---! Self-contained eql_v3 copies of the Order-Revealing Encryption block types ---! (design D1/D3). The eql_v2 originals are unchanged. - ---! @brief ORE block term type for Order-Revealing Encryption ---! ---! Composite type representing a single ORE block term. Stores encrypted data ---! as bytea that enables range comparisons without decryption. -CREATE TYPE eql_v3_internal.ore_block_256_term AS ( - bytes bytea -); - - ---! @brief ORE block index term type for range queries ---! ---! Composite type containing an array of ORE block terms. The array is stored ---! in the 'ob' field of encrypted data payloads. ---! ---! @note Transient type used only during query execution. -CREATE TYPE eql_v3_internal.ore_block_256 AS ( - terms eql_v3_internal.ore_block_256_term[] -); - ---! @file v3/sem/ore_block_256/functions.sql ---! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). ---! ---! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The ---! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array ---! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and ---! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments ---! deliberately avoid naming eql_v2 symbols so the self-containment grep stays ---! clean.) - ---! @brief Convert JSONB array to ORE block composite type ---! @internal ---! @param val jsonb Array of hex-encoded ORE block terms ---! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null ---! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the ---! planner can fold this per-encrypted-value helper into the calling query. ---! This deliberately diverges from the v2 plpgsql equivalent (intentionally ---! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only ---! evaluates the array path for an array, so a non-array JSON scalar returns ---! NULL here instead of raising. The sole caller (`ore_block_256`) only reaches ---! this when `has_ore_block_256(val)` is true, which now requires `val->'ob'` ---! to be a JSON array, so the non-array branch is unreachable in practice. ---! An empty array (`ob: []`, what encrypting the empty string `""` produces) ---! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms. ---! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and ---! NULL terms make the comparator return NULL (so an empty-text row silently ---! drops out of ordered queries). An empty array instead engages the ---! comparator's `cardinality = 0` guard, which sorts empty BEFORE every ---! non-empty term. See issue #262 (pinned by T7). -CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb) -RETURNS eql_v3_internal.ore_block_256 - IMMUTABLE -AS $$ - SELECT CASE WHEN jsonb_typeof(val) = 'array' - THEN ROW(COALESCE( - ( - SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) - FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b - ), - ARRAY[]::eql_v3_internal.ore_block_256_term[] - ))::eql_v3_internal.ore_block_256 - ELSE NULL - END; -$$ LANGUAGE sql; - ---! @internal Mark this hand-written helper inline-critical so the post-install ---! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving ---! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed ---! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does ---! not recognise it; this marker is the documented manual opt-in. -COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS - 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; - - ---! @brief Extract ORE block index term from JSONB payload ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.ore_block_256 ORE block index term ---! @throws Exception if 'ob' field is missing -CREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb) - RETURNS eql_v3_internal.ore_block_256 - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without - -- entering the body, so no explicit `val IS NULL` guard is needed. - IF eql_v3_internal.has_ore_block_256(val) THEN - RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob'); - END IF; - RAISE 'Expected an ore index (ob) value in json: %', val; - END; -$$ LANGUAGE plpgsql; - - ---! @brief Check if JSONB payload contains an ORE block index term ---! @param val jsonb containing encrypted EQL payload ---! @return boolean True only if the 'ob' field is present and is a JSON array ---! @note A well-formed ORE index term is always a JSON array of block terms, so ---! this guard treats a present-but-non-array `ob` (a scalar or object) as ---! absent. That makes the extractor `ore_block_256(val)` RAISE on a ---! structurally invalid `ob` payload at the boundary instead of silently ---! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The ---! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so ---! reported them as present. `{}` (absent `ob`) and `{"ob": null}` (JSON null) ---! both remain `false`. -CREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false); - END; -$$ LANGUAGE plpgsql; - - ---! @brief Compare two ORE block terms using cryptographic comparison ---! @internal ---! @param a eql_v3_internal.ore_block_256_term First ORE term ---! @param b eql_v3_internal.ore_block_256_term Second ORE term ---! @return integer -1 if a < b, 0 if a = b, 1 if a > b ---! @throws Exception if ciphertexts are different lengths ---! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)` ---! overloads all are). This deliberately diverges from the v2 originals, ---! which carry no volatility marker and so default to `VOLATILE`. The ---! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`, ---! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the ---! planner fold/cache these in ordering and index contexts. NOT `STRICT`: ---! the NULL-handling branches below are load-bearing for the array overload. -CREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term) - RETURNS integer - IMMUTABLE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - eq boolean := true; - unequal_block smallint := 0; - hash_key bytea; - data_block bytea; - encrypt_block bytea; - target_block bytea; - - left_block_size CONSTANT smallint := 16; - right_block_size CONSTANT smallint := 32; - - -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8. - -- Wire format per term: - -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ] - -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49 - -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric - -- (N=14, 702B) with one comparator. - n integer; - left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes) - right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N) - - indicator smallint := 0; - BEGIN - IF a IS NULL AND b IS NULL THEN - RETURN 0; - END IF; - - IF a IS NULL THEN - RETURN -1; - END IF; - - IF b IS NULL THEN - RETURN 1; - END IF; - - IF bit_length(a.bytes) != bit_length(b.bytes) THEN - RAISE EXCEPTION 'Ciphertexts are different lengths'; - END IF; - - -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The - -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0 - -- and derives N = 0, which would fall through to the all-blocks-equal path - -- and return 0 instead of raising. The `<= 16` clause is load-bearing. - IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN - RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes); - END IF; - - n := (octet_length(a.bytes) - 16) / 49; - left_offset := 1 + n; -- left blocks begin right after the N PRP bytes - right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT - - FOR block IN 0..n-1 LOOP - -- Compare each PRP byte (the first N bytes) and its 16-byte left block. - IF - substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1) - OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size) - THEN - IF eq THEN - unequal_block := block; - END IF; - eq = false; - END IF; - END LOOP; - - IF eq THEN - RETURN 0::integer; - END IF; - - -- Hash key is the IV from the right CT of b. - hash_key := substr(b.bytes, right_offset + 1, 16); - - -- First right block is at right_offset + nonce_size (ordinally indexed). - target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size); - - data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size); - - encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb'); - - indicator := ( - get_bit( - encrypt_block, - 0 - ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2; - - IF indicator = 1 THEN - RETURN 1::integer; - ELSE - RETURN -1::integer; - END IF; - END; -$$ LANGUAGE plpgsql; - - ---! @brief Compare arrays of ORE block terms recursively ---! @internal ---! @param a eql_v3_internal.ore_block_256_term[] First array ---! @param b eql_v3_internal.ore_block_256_term[] Second array ---! @return integer -1/0/1, or NULL if either array is NULL -CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[]) -RETURNS integer - IMMUTABLE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - cmp_result integer; - BEGIN - IF a IS NULL OR b IS NULL THEN - RETURN NULL; - END IF; - - IF cardinality(a) = 0 AND cardinality(b) = 0 THEN - RETURN 0; - END IF; - - IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN - RETURN -1; - END IF; - - IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN - RETURN 1; - END IF; - - cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]); - - IF cmp_result = 0 THEN - RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); - END IF; - - RETURN cmp_result; - END -$$ LANGUAGE plpgsql; - - ---! @brief Compare ORE block composite types ---! @internal ---! @param a eql_v3_internal.ore_block_256 First ORE block ---! @param b eql_v3_internal.ore_block_256 Second ORE block ---! @return integer -1/0/1 -CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS integer - IMMUTABLE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms); - END -$$ LANGUAGE plpgsql; - ---! @file v3/sem/ope_cllw/types.sql ---! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM) ---! ---! Domain type representing a CLLW (Copyless Logarithmic Width) ---! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in ---! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the ---! domain carries the hex-decoded bytes. ---! ---! A DOMAIN over bytea, not a composite: the OPE ciphertext is ---! order-preserving under plain byte comparison, so the domain inherits ---! bytea's native comparison operators and DEFAULT btree operator class ---! outright — no hand-written operators, comparator, or operator class (the ---! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole ---! comparison chain inlinable, so a functional btree index on ---! `eql_v3.ord_ope_term(col)` engages structurally for the `_ord_ope` ---! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec ---! CLLW-*ORE* composite compared by a custom per-byte protocol. ---! ---! @note Transient type used only during query execution. ---! @see eql_v3_internal.ope_cllw -CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; - ---! @file v3/sem/hmac_256/types.sql ---! @brief HMAC-SHA256 index term type (eql_v3 SEM) ---! ---! Domain type representing HMAC-SHA256 hash values. Used for exact-match ---! encrypted searches. The hash is stored in the 'hm' field of encrypted data ---! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is ---! unchanged. ---! ---! @note Transient type used only during query execution. -CREATE DOMAIN eql_v3_internal.hmac_256 AS text; - ---! @file v3/sem/bloom_filter/types.sql ---! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. - ---! @brief Bloom-filter index term: a bit array stored as smallint[]. ---! ---! Backs the `match` capability (`@>` / `<@`) on `eql_v3_internal.text_match`. The ---! filter is read from the `bf` field of an encrypted jsonb payload. Native ---! `smallint[]` array-containment (`@>`/`<@`) is inherited through the domain, ---! so this type needs no custom operators. ---! ---! @note Self-contained: references no eql_v2 symbol. -CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; - ---! @file v3/sem/ore_cllw/types.sql ---! @brief CLLW ORE index term type for STE-vec range queries (eql_v3 SEM) ---! ---! Composite type for CLLW (Copyless Logarithmic Width) Order-Revealing ---! Encryption. The ciphertext is stored in the `oc` field of encrypted data ---! payloads (Standard-mode `ste_vec` elements). Used by the range operators ---! (`<`, `<=`, `>`, `>=`) when an sv element carries an `oc` term. ---! ---! The wire-format `oc` value is a hex string with a leading domain-tag byte ---! (`0x00` numeric, `0x01` string) followed by the CLLW ciphertext. The ---! decoded `bytes` field carries the full byte string including the tag — the ---! comparator is variable-length capable, so numeric and string values within ---! the same column order correctly: the domain tag separates the ranges ---! (numeric < string) and the within-domain comparison falls through to the ---! CLLW per-byte protocol. ---! ---! @note This is a transient type used only during query execution. ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE TYPE eql_v3_internal.ore_cllw AS ( - bytes bytea -); --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/timestamp/timestamp_types.sql ---! @brief Encrypted-domain types for timestamp. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.timestamp. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.timestamp_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.timestamp_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.timestamp_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.timestamp_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; - ---! @file v3/scalars/functions.sql ---! @brief Shared blocker helper for the eql_v3 encrypted-domain families. ---! ---! Per-domain wrapper functions live in src/v3/scalars//. ---! Blockers in those files delegate to encrypted_domain_unsupported_bool ---! so every domain raises a uniform domain-specific error rather than ---! letting an unsupported operator fall through to native jsonb ---! behaviour. - ---! @brief Shared blocker helper. Raises 'operator X is not supported ---! for TYPE' so unsupported domain operators surface a clear ---! error rather than fall through to native jsonb behaviour. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (=, <, @>, ->, etc.) ---! @return boolean (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @brief Shared blocker helper returning jsonb. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! native operators whose result is jsonb (#>, -, #-, ||), so composed ---! expressions resolve and the body raises rather than failing earlier ---! with a misleading 'operator does not exist' on a boolean result. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>, -, #-, ||, etc.) ---! @return jsonb (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @brief Shared blocker helper returning text. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! the native #>> operator whose result is text. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>>) ---! @return text (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) -RETURNS text -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @file v3/sem/ore_block_256/operators.sql ---! @brief Comparison operators on eql_v3_internal.ore_block_256. ---! ---! The six backing functions are inlinable single-statement SQL so the planner ---! can fold the eql_v3 comparison wrappers through to functional-index matching. - ---! @brief Equality backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the ORE blocks are equal ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0 -$$; - ---! @brief Not-equal backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the ORE blocks are not equal ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0 -$$; - ---! @brief Less-than backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the left operand is less than the right operand ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1 -$$; - ---! @brief Less-than-or-equal backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the left operand is less than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1 -$$; - ---! @brief Greater-than backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the left operand is greater than the right operand ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1 -$$; - ---! @brief Greater-than-or-equal backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the left operand is greater than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1 -$$; - - ---! @brief = operator for ORE block types ---! ---! COMMUTATOR is the operator itself: equality is symmetric. Required for the ---! MERGES flag — without it the planner raises "could not find commutator" the ---! first time an ore_block equality is used as a join qual (e.g. via the inlined ---! eql_v3_internal._ord_ore equality wrappers). -CREATE OPERATOR public.= ( - FUNCTION=eql_v3_internal.ore_block_256_eq, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.=), - NEGATOR = OPERATOR(public.<>), - RESTRICT = eqsel, - JOIN = eqjoinsel, - HASHES, - MERGES -); - ---! @brief <> operator for ORE block types -CREATE OPERATOR public.<> ( - FUNCTION=eql_v3_internal.ore_block_256_neq, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.<>), - NEGATOR = OPERATOR(public.=), - RESTRICT = neqsel, - JOIN = neqjoinsel, - MERGES -); - ---! @brief > operator for ORE block types -CREATE OPERATOR public.> ( - FUNCTION=eql_v3_internal.ore_block_256_gt, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.<), - NEGATOR = OPERATOR(public.<=), - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel -); - ---! @brief < operator for ORE block types -CREATE OPERATOR public.< ( - FUNCTION=eql_v3_internal.ore_block_256_lt, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.>), - NEGATOR = OPERATOR(public.>=), - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel -); - ---! @brief <= operator for ORE block types -CREATE OPERATOR public.<= ( - FUNCTION=eql_v3_internal.ore_block_256_lte, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.>=), - NEGATOR = OPERATOR(public.>), - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel -); - ---! @brief >= operator for ORE block types -CREATE OPERATOR public.>= ( - FUNCTION=eql_v3_internal.ore_block_256_gte, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.<=), - NEGATOR = OPERATOR(public.<), - RESTRICT = scalargesel, - JOIN = scalargejoinsel -); - ---! @file v3/sem/ope_cllw/functions.sql ---! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM). - ---! @brief Extract CLLW OPE index term from JSONB payload ---! ---! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar ---! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain. ---! ---! Inlinable single-statement SQL — the body is a strict expression of the ---! argument (`->>` and `decode` are both STRICT), so the planner folds this ---! into the calling query and functional btree indexes built on ---! `eql_v3.ord_ope_term(col)` (which calls this) engage structurally, the ---! same way the hmac_256 equality chain does. ---! ---! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and ---! the strict chain propagates it, so the extractor returns SQL NULL and ---! btree's NULL handling filters those rows from range queries. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is ---! absent -CREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb) - RETURNS eql_v3_internal.ope_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw -$$; - -COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)'; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/text/text_types.sql ---! @brief Encrypted-domain types for text. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.text. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_match. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_match' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_match AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'bf' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_search. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_search' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_search AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND VALUE ? 'bf' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; - ---! @file v3/sem/hmac_256/functions.sql ---! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). ---! ---! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and ---! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar ---! domains extract from the jsonb payload directly via a cast to the domain. ---! (Doc comments deliberately avoid naming eql_v2 symbols so the ---! self-containment grep stays clean.) - ---! @brief Extract HMAC-SHA256 index term from JSONB payload ---! ---! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` ---! (which calls this) engage structurally. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent -CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) - RETURNS eql_v3_internal.hmac_256 - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 -$$; - - ---! @brief Check if JSONB payload contains HMAC-SHA256 index term ---! ---! @param val jsonb containing encrypted EQL payload ---! @return boolean True if 'hm' field is present and non-null -CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) - RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm') IS NOT NULL -$$; - ---! @file v3/sem/bloom_filter/functions.sql ---! @brief Extractor for the eql_v3 Bloom-filter SEM index term. ---! ---! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column ---! overloads are intentionally omitted — the eql_v3 scalar domains extract from ---! the jsonb payload directly via a cast to the domain. (Doc comments ---! deliberately avoid naming eql_v2 symbols so the self-containment grep stays ---! clean.) - ---! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term. ---! ---! @param val jsonb The encrypted payload. ---! @return boolean True when the `bf` key is present and non-null. ---! ---! @internal Defined for parity with the eql_v3 SEM index-term predicates ---! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by ---! the extractor below, which gates on value-shape inline, nor by the generated ---! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept ---! as the canonical presence test for callers that need one. -CREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL; - END; -$$ LANGUAGE plpgsql; - ---! @brief Extract the Bloom-filter index term from a jsonb payload. ---! ---! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which ---! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE ---! and no pinned `search_path`. Returns NULL when `bf` is absent or present but ---! not a json array, rather than raising. The `text_match` domain CHECK ---! guarantees the `bf` *key* is present but not that it is an array, so a ---! non-array `bf` (e.g. `{"bf": null}`) can reach here even on a typed value; ---! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for ---! raw jsonb outside the domain — instead of erroring inside ---! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An ---! empty `bf` array yields an empty filter (contains nothing, contained by ---! everything), matching set-containment semantics. ---! ---! @param val jsonb The encrypted payload. ---! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or ---! NULL when `bf` is absent or not a json array. -CREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb) - RETURNS eql_v3_internal.bloom_filter - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array' - THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter - END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/smallint/smallint_types.sql ---! @brief Encrypted-domain types for smallint. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.smallint. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.smallint_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.smallint_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.smallint_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.smallint_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/real/real_types.sql ---! @brief Encrypted-domain types for real. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.real. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.real_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.real_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.real_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.real_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/numeric/numeric_types.sql ---! @brief Encrypted-domain types for numeric. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.numeric. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.numeric_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.numeric_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.numeric_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.numeric_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/integer/integer_types.sql ---! @brief Encrypted-domain types for integer. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.integer. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.integer_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.integer_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.integer_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.integer_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/double/double_types.sql ---! @brief Encrypted-domain types for double. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.double. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.double_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.double_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.double_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.double_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/date/date_types.sql ---! @brief Encrypted-domain types for date. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.date. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.date_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.date_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.date_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.date_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/bigint/bigint_types.sql ---! @brief Encrypted-domain types for bigint. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.bigint. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.bigint_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.bigint_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.bigint_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.bigint_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; - ---! @file v3/sem/ore_cllw/functions.sql ---! @brief CLLW ORE index-term extraction and comparison (eql_v3 SEM). - ---! @brief Extract CLLW ORE index term from raw jsonb ---! ---! Returns the CLLW ORE ciphertext from the `oc` field of a single sv element ---! supplied as raw jsonb. Inlinable single-statement SQL — the planner folds ---! the body into the calling query. ---! ---! **Missing-`oc` semantics**: returns SQL-level NULL (not a composite with ---! NULL bytes) when `oc` is absent, so btree's NULL handling filters those ---! rows from range queries. ---! ---! @param val jsonb An object carrying an `oc` field ---! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL ---! when the `oc` field is absent. ---! @see eql_v3_internal.has_ore_cllw ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw(val jsonb) - RETURNS eql_v3_internal.ore_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN val ->> 'oc' IS NULL THEN NULL - ELSE ROW(decode(val ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw - END -$$; - -COMMENT ON FUNCTION eql_v3_internal.ore_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW extractor; must stay inlinable (unpinned search_path)'; - ---! @brief Check if a raw jsonb value contains a CLLW ORE index term ---! @param val jsonb An object that may carry an `oc` field ---! @return boolean True if `oc` field is present and non-null -CREATE FUNCTION eql_v3_internal.has_ore_cllw(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT val ->> 'oc' IS NOT NULL -$$; - -COMMENT ON FUNCTION eql_v3_internal.has_ore_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW presence helper; must stay inlinable (unpinned search_path)'; - ---! @brief CLLW per-byte comparison helper ---! @internal ---! ---! Byte-by-byte comparison implementing the CLLW order-revealing protocol. ---! Identify the index of the first differing byte; if `(y_byte + 1) == x_byte` ---! (mod 256) there, then x > y; otherwise x < y. Equal inputs return 0. Inputs ---! MUST be the same length (the caller guarantees this). Stays `LANGUAGE ---! plpgsql` — the per-byte loop can't be a single inlinable SQL expression. ---! ---! @param a bytea First CLLW ciphertext slice ---! @param b bytea Second CLLW ciphertext slice ---! @return integer -1, 0, or 1 ---! @throws Exception if inputs are different lengths ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term_bytes(a bytea, b bytea) -RETURNS int - SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - len_a INT; - len_b INT; - i INT; - first_diff INT := 0; -BEGIN - - len_a := LENGTH(a); - len_b := LENGTH(b); - - IF len_a != len_b THEN - RAISE EXCEPTION 'ore_cllw index terms are not the same length'; - END IF; - - FOR i IN 1..len_a LOOP - IF first_diff = 0 AND get_byte(a, i - 1) != get_byte(b, i - 1) THEN - first_diff := i; - END IF; - END LOOP; - - IF first_diff = 0 THEN - RETURN 0; - END IF; - - IF ((get_byte(b, first_diff - 1) + 1) & 255) = get_byte(a, first_diff - 1) THEN - RETURN 1; - ELSE - RETURN -1; - END IF; -END; -$$ LANGUAGE plpgsql; - ---! @brief Variable-length CLLW ORE term comparison ---! @internal ---! ---! Three-way comparison of two CLLW ORE ciphertext terms of potentially ---! different lengths. Compares the shared prefix via the CLLW per-byte ---! protocol; on equal prefixes, the shorter input sorts first. The leading ---! domain-tag byte makes numeric (`0x00`) sort before string (`0x01`). Stays ---! `LANGUAGE plpgsql` because it dispatches to `compare_ore_cllw_term_bytes`. ---! ---! btree filters NULL composites at the row level, so this should never see a ---! NULL composite under normal operation; the IS-NULL guard returns NULL ---! defensively. A non-NULL composite with NULL `bytes` is a contract violation ---! — the extractor returns SQL NULL (not ROW(NULL)) on missing `oc`, so raise ---! loudly rather than silently misorder. ---! ---! @param a eql_v3_internal.ore_cllw First term ---! @param b eql_v3_internal.ore_cllw Second term ---! @return integer -1, 0, or 1; NULL if either composite is NULL ---! @throws Exception if either composite has a NULL `bytes` field ---! @see eql_v3_internal.compare_ore_cllw_term_bytes -CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) -RETURNS int - SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - len_a INT; - len_b INT; - common_len INT; - cmp_result INT; -BEGIN - -- The `::text` cast is load-bearing, not a stylistic choice. For the - -- single-field `ore_cllw` composite, `ROW(NULL)::ore_cllw IS NULL` is TRUE - -- but `(ROW(NULL)::ore_cllw)::text IS NULL` is FALSE. Casting to text first - -- means a NULL-component composite falls THROUGH to the RAISE below (the - -- extractor-invariant violation) instead of silently returning NULL and - -- masking it. A plain `a IS NULL` would reintroduce that masking bug. - IF a::text IS NULL OR b::text IS NULL THEN - RETURN NULL; - END IF; - - IF a.bytes IS NULL OR b.bytes IS NULL THEN - RAISE EXCEPTION 'eql_v3_internal.compare_ore_cllw_term: composite has NULL bytes field — extractor invariant violated. Check that the index expression uses eql_v3_internal.ore_cllw(...) and not a hand-crafted ROW(NULL).'; - END IF; - - len_a := LENGTH(a.bytes); - len_b := LENGTH(b.bytes); - - IF len_a = 0 AND len_b = 0 THEN - RETURN 0; - ELSIF len_a = 0 THEN - RETURN -1; - ELSIF len_b = 0 THEN - RETURN 1; - END IF; - - IF len_a < len_b THEN - common_len := len_a; - ELSE - common_len := len_b; - END IF; - - cmp_result := eql_v3_internal.compare_ore_cllw_term_bytes( - SUBSTRING(a.bytes FROM 1 FOR common_len), - SUBSTRING(b.bytes FROM 1 FOR common_len) - ); - - IF cmp_result = -1 THEN - RETURN -1; - ELSIF cmp_result = 1 THEN - RETURN 1; - END IF; - - IF len_a < len_b THEN - RETURN -1; - ELSIF len_a > len_b THEN - RETURN 1; - ELSE - RETURN 0; - END IF; -END; -$$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql ---! @brief Functions for eql_v3.timestamp_ord_ore. - ---! @brief Index extractor for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param selector text ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector text) -RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param selector integer ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector integer) -RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ore) -RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql ---! @brief Functions for eql_v3.timestamp_ord_ope. - ---! @brief Index extractor for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.timestamp_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param selector text ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector text) -RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param selector integer ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector integer) -RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ope) -RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_functions.sql ---! @brief Functions for eql_v3.timestamp_ord. - ---! @brief Index extractor for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param selector text ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector text) -RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param selector integer ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector integer) -RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord) -RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_search_functions.sql ---! @brief Functions for eql_v3.text_search. - ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_search) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_search) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.text_search) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) <@ eql_v3.match_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param selector text ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector text) -RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param selector integer ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector integer) -RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a jsonb ---! @param selector eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_search) -RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a jsonb ---! @param selector eql_v3.text_search ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_search) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_search, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_search, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_search, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_search, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_search, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_search, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b eql_v3.text_search) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_search) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ore_functions.sql ---! @brief Functions for eql_v3.text_ord_ore. - ---! @brief Index extractor for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param selector text ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector text) -RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param selector integer ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector integer) -RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.text_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ope_functions.sql ---! @brief Functions for eql_v3.text_ord_ope. - ---! @brief Index extractor for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord_ope) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.text_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param selector text ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector text) -RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param selector integer ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector integer) -RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ope) -RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.text_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_functions.sql ---! @brief Functions for eql_v3.text_ord. - ---! @brief Index extractor for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param selector text ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector text) -RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param selector integer ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector integer) -RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param selector eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord) -RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param selector eql_v3.text_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql ---! @brief Functions for eql_v3.smallint_ord_ore. - ---! @brief Index extractor for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.smallint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param selector text ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector text) -RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param selector integer ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector integer) -RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ore) -RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql ---! @brief Functions for eql_v3.smallint_ord_ope. - ---! @brief Index extractor for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.smallint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param selector text ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector text) -RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param selector integer ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector integer) -RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ope) -RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_functions.sql ---! @brief Functions for eql_v3.smallint_ord. - ---! @brief Index extractor for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.smallint_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param selector text ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector text) -RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param selector integer ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector integer) -RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord) -RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ore_functions.sql ---! @brief Functions for eql_v3.real_ord_ore. - ---! @brief Index extractor for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.real_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param selector text ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector text) -RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param selector integer ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector integer) -RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ore) -RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.real_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ope_functions.sql ---! @brief Functions for eql_v3.real_ord_ope. - ---! @brief Index extractor for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.real_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param selector text ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector text) -RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param selector integer ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector integer) -RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ope) -RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.real_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_functions.sql ---! @brief Functions for eql_v3.real_ord. - ---! @brief Index extractor for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.real_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param selector text ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector text) -RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param selector integer ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector integer) -RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param selector eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord) -RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param selector eql_v3.real_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql ---! @brief Functions for eql_v3.numeric_ord_ore. - ---! @brief Index extractor for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param selector text ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector text) -RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param selector integer ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector integer) -RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ore) -RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql ---! @brief Functions for eql_v3.numeric_ord_ope. - ---! @brief Index extractor for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.numeric_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param selector text ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector text) -RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param selector integer ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector integer) -RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ope) -RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_functions.sql ---! @brief Functions for eql_v3.numeric_ord. - ---! @brief Index extractor for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector text ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector text) -RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector integer ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector integer) -RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord) -RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ore_functions.sql ---! @brief Functions for eql_v3.integer_ord_ore. - ---! @brief Index extractor for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.integer_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param selector text ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector text) -RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param selector integer ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector integer) -RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ore) -RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.integer_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ope_functions.sql ---! @brief Functions for eql_v3.integer_ord_ope. - ---! @brief Index extractor for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.integer_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param selector text ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector text) -RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param selector integer ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector integer) -RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ope) -RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.integer_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_functions.sql ---! @brief Functions for eql_v3.integer_ord. - ---! @brief Index extractor for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.integer_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param selector text ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector text) -RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param selector integer ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector integer) -RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param selector eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord) -RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param selector eql_v3.integer_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ore_functions.sql ---! @brief Functions for eql_v3.double_ord_ore. - ---! @brief Index extractor for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.double_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param selector text ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector text) -RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param selector integer ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector integer) -RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ore) -RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.double_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ope_functions.sql ---! @brief Functions for eql_v3.double_ord_ope. - ---! @brief Index extractor for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.double_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param selector text ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector text) -RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param selector integer ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector integer) -RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ope) -RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.double_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_functions.sql ---! @brief Functions for eql_v3.double_ord. - ---! @brief Index extractor for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.double_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param selector text ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector text) -RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param selector integer ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector integer) -RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param selector eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord) -RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param selector eql_v3.double_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ore_functions.sql ---! @brief Functions for eql_v3.date_ord_ore. - ---! @brief Index extractor for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param selector text ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector text) -RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param selector integer ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector integer) -RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ore) -RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.date_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ope_functions.sql ---! @brief Functions for eql_v3.date_ord_ope. - ---! @brief Index extractor for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.date_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param selector text ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector text) -RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param selector integer ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector integer) -RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ope) -RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.date_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_functions.sql ---! @brief Functions for eql_v3.date_ord. - ---! @brief Index extractor for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param selector text ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector text) -RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param selector integer ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector integer) -RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param selector eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord) -RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param selector eql_v3.date_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/boolean/boolean_types.sql ---! @brief Encrypted-domain types for boolean. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.boolean. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'boolean' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.boolean AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql ---! @brief Functions for eql_v3.bigint_ord_ore. - ---! @brief Index extractor for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.bigint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param selector text ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector text) -RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param selector integer ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector integer) -RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ore) -RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql ---! @brief Functions for eql_v3.bigint_ord_ope. - ---! @brief Index extractor for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.bigint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param selector text ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector text) -RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param selector integer ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector integer) -RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ope) -RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_functions.sql ---! @brief Functions for eql_v3.bigint_ord. - ---! @brief Index extractor for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.bigint_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param selector text ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector text) -RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param selector integer ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector integer) -RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord) -RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @file v3/jsonb/types.sql ---! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! Three jsonb-backed domains (none over another domain — operators resolve ---! against the ultimate base type jsonb, so the native-jsonb firewall in ---! blockers.sql can attach): ---! - eql_v3.json — storage/root: an EQL envelope object ({i, v, ...}). ---! - eql_v3.jsonb_entry — a single sv element (returned by `->`). ---! - eql_v3.jsonb_query — a containment needle (sv elements, no ciphertext). - ---! @brief Validate a single SteVec entry payload. ---! @internal ---! @param val jsonb Candidate entry payload. ---! @return boolean True when `val` is an sv entry with string `s`, string `c`, ---! and exactly one string deterministic term (`hm` XOR `oc`). -CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_entry_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 's') = 'string' - AND jsonb_typeof(val -> 'c') = 'string' - AND ( - (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'oc')) - OR - (jsonb_typeof(val -> 'oc') = 'string' AND NOT (val ? 'hm')) - ), - false - ) -$$; - ---! @brief Validate a SteVec containment query payload. ---! @internal ---! @param val jsonb Candidate query payload. ---! @return boolean True when `val` is `{"sv":[...]}` and every element carries ---! string `s`, no ciphertext, and exactly one string term (`hm` XOR ---! `oc`). -CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_query_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT COALESCE(( - jsonb_typeof(elem) = 'object' - AND jsonb_typeof(elem -> 's') = 'string' - AND NOT (elem ? 'c') - AND ( - (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'oc')) - OR - (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) - ) - ), false) - ), - false - ) -$$; - ---! @brief Validate a root SteVec document payload. ---! @internal ---! @param val jsonb Candidate document payload. ---! @return boolean True when `val` is an encrypted document envelope with ---! `v = 3`, `i`, an `sv` array, and valid sv entry elements. -CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_document_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND val ? 'v' - AND val ->> 'v' = '3' - AND val ? 'i' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT eql_v3_internal.is_valid_ste_vec_entry_payload(elem) - ), - false - ) -$$; - ---! @brief Storage/root domain for an encrypted JSONB column. ---! ---! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index ---! metadata). Root `c` is intentionally NOT required — an sv-array root payload ---! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` ---! array, so the domain accepts only SteVec **document** payloads and rejects ---! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is ---! what keeps `eql_v3.json` a typed document domain rather than a generic ---! encrypted envelope. The firewall in blockers.sql attaches to this domain to ---! stop native jsonb operators from reaching a column value. ---! ---! @note Constructing from inline JSON uses the standard DOMAIN cast: ---! `'{"i":{},"v":3,"sv":[...]}'::eql_v3.json`. -CREATE DOMAIN eql_v3.json AS jsonb - CHECK ( - eql_v3_internal.is_valid_ste_vec_document_payload(VALUE) - ); - ---! @brief Domain type for an individual sv element. ---! ---! A single element inside an `sv` array: a JSON object that carries a selector ---! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for ---! hash-equality) or `oc` (CLLW ORE, for ordered queries) — they are mutually ---! exclusive. This is the type returned by `->` and accepted by the per-entry ---! extractors `eql_v3.eq_term` / `eql_v3.ore_cllw`. Extra fields (`a`, root ---! `i`/`v` merged in by `->`) are allowed. ---! ---! @see src/v3/jsonb/operators.sql -CREATE DOMAIN eql_v3.jsonb_entry AS jsonb - CHECK ( - eql_v3_internal.is_valid_ste_vec_entry_payload(VALUE) - ); - ---! @brief Domain type for an STE-vec containment needle. ---! ---! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index ---! term but **never** a ciphertext (`c`). Each element must carry `s` and ---! exactly one deterministic term (`hm` XOR `oc`). Typing the needle this way ---! stops selector-only needles from casting and matching every row via bare ---! `jsonb @>`. ---! ---! @note Construct from inline JSON via the DOMAIN cast: ---! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.jsonb_query`. ---! @see eql_v3.to_ste_vec_query -CREATE DOMAIN eql_v3.jsonb_query AS jsonb - CHECK ( - eql_v3_internal.is_valid_ste_vec_query_payload(VALUE) - ); - ---! @brief Convert an eql_v3.json to a jsonb_query needle. ---! ---! Normalises each sv element down to the matching-relevant fields: `s` plus ---! exactly one of `hm` / `oc`. Other fields (`c`, `a`, `i`/`v`, anything else) ---! are stripped. This is the canonical needle shape for `@>` containment. ---! Designed for use as a functional GIN index expression: ---! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. ---! ---! @param e eql_v3.json Source encrypted payload ---! @return eql_v3.jsonb_query Query-shaped needle, sv elements normalised. ---! @see eql_v3.jsonb_query -CREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.json) - RETURNS eql_v3.jsonb_query - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT jsonb_build_object( - 'sv', - coalesce( - (SELECT jsonb_agg( - jsonb_strip_nulls( - jsonb_build_object( - 's', elem -> 's', - 'hm', elem -> 'hm', - 'oc', elem -> 'oc' - ) - ) - ) - FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), - '[]'::jsonb - ) - )::eql_v3.jsonb_query -$$; - -CREATE CAST (eql_v3.json AS eql_v3.jsonb_query) - WITH FUNCTION eql_v3.to_ste_vec_query - AS ASSIGNMENT; - ---! @file v3/sem/ore_cllw/operators.sql ---! @brief Comparison operators on the eql_v3_internal.ore_cllw composite type. ---! ---! Each backing function reduces to a single SELECT over ---! eql_v3_internal.compare_ore_cllw_term(a, b) and is inlinable so the planner can fold ---! it through to functional-index matching. The inner comparator is plpgsql ---! (per-byte loop) and is not inlined — fine for index *match*. ---! ---! @note Deliberately no HASHES / MERGES — the CLLW protocol gives ordering, ---! not a hash; there is no merge-joinable opclass on the other side. ---! @see eql_v3_internal.compare_ore_cllw_term - ---! @brief Equality backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the CLLW ORE terms are equal ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_eq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 0 -$$; - ---! @brief Not-equal backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the CLLW ORE terms are not equal ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_neq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 0 -$$; - ---! @brief Less-than backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is less than the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_lt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = -1 -$$; - ---! @brief Less-than-or-equal backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is less than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_lte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 1 -$$; - ---! @brief Greater-than backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is greater than the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_gt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 1 -$$; - ---! @brief Greater-than-or-equal backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is greater than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_gte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> -1 -$$; - - -CREATE OPERATOR public.= ( - FUNCTION = eql_v3_internal.ore_cllw_eq, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.=), - NEGATOR = OPERATOR(public.<>), - RESTRICT = eqsel, - JOIN = eqjoinsel -); - -CREATE OPERATOR public.<> ( - FUNCTION = eql_v3_internal.ore_cllw_neq, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.<>), - NEGATOR = OPERATOR(public.=), - RESTRICT = neqsel, - JOIN = neqjoinsel -); - -CREATE OPERATOR public.< ( - FUNCTION = eql_v3_internal.ore_cllw_lt, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.>), - NEGATOR = OPERATOR(public.>=), - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel -); - -CREATE OPERATOR public.<= ( - FUNCTION = eql_v3_internal.ore_cllw_lte, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.>=), - NEGATOR = OPERATOR(public.>), - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel -); - -CREATE OPERATOR public.> ( - FUNCTION = eql_v3_internal.ore_cllw_gt, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.<), - NEGATOR = OPERATOR(public.<=), - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel -); - -CREATE OPERATOR public.>= ( - FUNCTION = eql_v3_internal.ore_cllw_gte, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.<=), - NEGATOR = OPERATOR(public.<), - RESTRICT = scalargesel, - JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql ---! @brief Operators for eql_v3.timestamp_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql ---! @brief Operators for eql_v3.timestamp_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_operators.sql ---! @brief Operators for eql_v3.timestamp_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_functions.sql ---! @brief Functions for eql_v3.timestamp. - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector text ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector text) -RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector integer ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector integer) -RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param selector eql_v3.timestamp ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp) -RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param selector eql_v3.timestamp ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_eq_functions.sql ---! @brief Functions for eql_v3.timestamp_eq. - ---! @brief Index extractor for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.timestamp_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param selector text ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector text) -RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param selector integer ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector integer) -RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param selector eql_v3.timestamp_eq ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_eq) -RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param selector eql_v3.timestamp_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_search_operators.sql ---! @brief Operators for eql_v3.text_search. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ore_operators.sql ---! @brief Operators for eql_v3.text_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ope_operators.sql ---! @brief Operators for eql_v3.text_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_operators.sql ---! @brief Operators for eql_v3.text_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_functions.sql ---! @brief Functions for eql_v3.text. - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param selector text ---! @return eql_v3.text -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector text) -RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param selector integer ---! @return eql_v3.text -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector integer) -RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param selector eql_v3.text ---! @return eql_v3.text -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text) -RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param selector eql_v3.text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b eql_v3.text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_match_functions.sql ---! @brief Functions for eql_v3.text_match. - ---! @brief Index extractor for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.text_match) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::eql_v3.text_match) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::eql_v3.text_match) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) <@ eql_v3.match_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param selector text ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector text) -RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param selector integer ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector integer) -RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param selector eql_v3.text_match ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_match) -RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param selector eql_v3.text_match ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_match) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_match, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_match, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_match, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_match, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_match, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_match, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_match, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_match, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b eql_v3.text_match) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_match) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_eq_functions.sql ---! @brief Functions for eql_v3.text_eq. - ---! @brief Index extractor for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_eq) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_eq) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param selector text ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector text) -RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param selector integer ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector integer) -RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param selector eql_v3.text_eq ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_eq) -RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param selector eql_v3.text_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql ---! @brief Operators for eql_v3.smallint_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql ---! @brief Operators for eql_v3.smallint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_operators.sql ---! @brief Operators for eql_v3.smallint_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_functions.sql ---! @brief Functions for eql_v3.smallint. - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector text ---! @return eql_v3.smallint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector text) -RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector integer ---! @return eql_v3.smallint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector integer) -RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param selector eql_v3.smallint ---! @return eql_v3.smallint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint) -RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param selector eql_v3.smallint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b eql_v3.smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_eq_functions.sql ---! @brief Functions for eql_v3.smallint_eq. - ---! @brief Index extractor for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.smallint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.smallint_eq) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.smallint_eq) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param selector text ---! @return eql_v3.smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector text) -RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param selector integer ---! @return eql_v3.smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector integer) -RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param selector eql_v3.smallint_eq ---! @return eql_v3.smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_eq) -RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param selector eql_v3.smallint_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ore_operators.sql ---! @brief Operators for eql_v3.real_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ope_operators.sql ---! @brief Operators for eql_v3.real_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_operators.sql ---! @brief Operators for eql_v3.real_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_functions.sql ---! @brief Functions for eql_v3.real. - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector text ---! @return eql_v3.real -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector text) -RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector integer ---! @return eql_v3.real -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector integer) -RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param selector eql_v3.real ---! @return eql_v3.real -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real) -RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param selector eql_v3.real ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b eql_v3.real) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_eq_functions.sql ---! @brief Functions for eql_v3.real_eq. - ---! @brief Index extractor for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.real_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.real_eq) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.real_eq) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector text ---! @return eql_v3.real_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector text) -RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector integer ---! @return eql_v3.real_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector integer) -RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param selector eql_v3.real_eq ---! @return eql_v3.real_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_eq) -RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param selector eql_v3.real_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql ---! @brief Operators for eql_v3.numeric_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql ---! @brief Operators for eql_v3.numeric_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_operators.sql ---! @brief Operators for eql_v3.numeric_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_functions.sql ---! @brief Functions for eql_v3.numeric. - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector text ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector text) -RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector integer ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector integer) -RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param selector eql_v3.numeric ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric) -RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param selector eql_v3.numeric ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b eql_v3.numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_eq_functions.sql ---! @brief Functions for eql_v3.numeric_eq. - ---! @brief Index extractor for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.numeric_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.numeric_eq) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.numeric_eq) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector text ---! @return eql_v3.numeric_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector text) -RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector integer ---! @return eql_v3.numeric_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector integer) -RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param selector eql_v3.numeric_eq ---! @return eql_v3.numeric_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_eq) -RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param selector eql_v3.numeric_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ore_operators.sql ---! @brief Operators for eql_v3.integer_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ope_operators.sql ---! @brief Operators for eql_v3.integer_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_operators.sql ---! @brief Operators for eql_v3.integer_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_functions.sql ---! @brief Functions for eql_v3.integer. - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param selector text ---! @return eql_v3.integer -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector text) -RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param selector integer ---! @return eql_v3.integer -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector integer) -RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param selector eql_v3.integer ---! @return eql_v3.integer -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer) -RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param selector eql_v3.integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b eql_v3.integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_eq_functions.sql ---! @brief Functions for eql_v3.integer_eq. - ---! @brief Index extractor for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.integer_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.integer_eq) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.integer_eq) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector text ---! @return eql_v3.integer_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector text) -RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector integer ---! @return eql_v3.integer_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector integer) -RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param selector eql_v3.integer_eq ---! @return eql_v3.integer_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_eq) -RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param selector eql_v3.integer_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ore_operators.sql ---! @brief Operators for eql_v3.double_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ope_operators.sql ---! @brief Operators for eql_v3.double_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_operators.sql ---! @brief Operators for eql_v3.double_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_functions.sql ---! @brief Functions for eql_v3.double. - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param selector text ---! @return eql_v3.double -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector text) -RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param selector integer ---! @return eql_v3.double -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector integer) -RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param selector eql_v3.double ---! @return eql_v3.double -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double) -RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param selector eql_v3.double ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b eql_v3.double) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_eq_functions.sql ---! @brief Functions for eql_v3.double_eq. - ---! @brief Index extractor for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.double_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.double_eq) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.double_eq) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector text ---! @return eql_v3.double_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector text) -RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector integer ---! @return eql_v3.double_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector integer) -RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param selector eql_v3.double_eq ---! @return eql_v3.double_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_eq) -RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param selector eql_v3.double_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ore_operators.sql ---! @brief Operators for eql_v3.date_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ope_operators.sql ---! @brief Operators for eql_v3.date_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_operators.sql ---! @brief Operators for eql_v3.date_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_functions.sql ---! @brief Functions for eql_v3.date. - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param selector text ---! @return eql_v3.date -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector text) -RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param selector integer ---! @return eql_v3.date -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector integer) -RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param selector eql_v3.date ---! @return eql_v3.date -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date) -RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param selector eql_v3.date ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b eql_v3.date) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_eq_functions.sql ---! @brief Functions for eql_v3.date_eq. - ---! @brief Index extractor for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.date_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.date_eq) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.date_eq) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector text ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector text) -RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector integer ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector integer) -RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param selector eql_v3.date_eq ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_eq) -RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param selector eql_v3.date_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/boolean/boolean_functions.sql ---! @brief Functions for eql_v3.boolean. - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector text ---! @return eql_v3.boolean -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector text) -RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector integer ---! @return eql_v3.boolean -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector integer) -RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param selector eql_v3.boolean ---! @return eql_v3.boolean -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.boolean) -RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param selector eql_v3.boolean ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.boolean) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.boolean, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.boolean, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b eql_v3.boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql ---! @brief Operators for eql_v3.bigint_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql ---! @brief Operators for eql_v3.bigint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_operators.sql ---! @brief Operators for eql_v3.bigint_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_functions.sql ---! @brief Functions for eql_v3.bigint. - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector text ---! @return eql_v3.bigint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector text) -RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector integer ---! @return eql_v3.bigint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector integer) -RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param selector eql_v3.bigint ---! @return eql_v3.bigint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint) -RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param selector eql_v3.bigint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b eql_v3.bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_eq_functions.sql ---! @brief Functions for eql_v3.bigint_eq. - ---! @brief Index extractor for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.bigint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.bigint_eq) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.bigint_eq) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector text ---! @return eql_v3.bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector text) -RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector integer ---! @return eql_v3.bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector integer) -RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param selector eql_v3.bigint_eq ---! @return eql_v3.bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_eq) -RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param selector eql_v3.bigint_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @file v3/jsonb/functions.sql ---! @brief Extractors, containment engine, and path/array functions for the ---! eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! `selector` parameters here are *encrypted-side* selector hashes — the ---! deterministic hash the crypto layer emits in the `s` field of each sv ---! element. Plaintext JSONPaths are never accepted at runtime. - ------------------------------------------------------------------------------- --- Envelope helpers (eql_v3 owns these; jsonb-only) ------------------------------------------------------------------------------- - ---! @brief Extract metadata (i, v) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return jsonb Metadata object with `i` and `v` fields. -CREATE FUNCTION eql_v3.meta_data(val jsonb) - RETURNS jsonb - IMMUTABLE STRICT PARALLEL SAFE - LANGUAGE SQL -AS $$ - SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); -$$; - -COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS - 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; - ---! @brief Extract ciphertext (c) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text Base64-encoded ciphertext. ---! @throws Exception if `c` is absent. -CREATE FUNCTION eql_v3.ciphertext(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'c' THEN - RETURN val->>'c'; - END IF; - RAISE 'Expected a ciphertext (c) value in json: %', val; - END; -$$ LANGUAGE plpgsql; - ------------------------------------------------------------------------------- --- Selector extractors ------------------------------------------------------------------------------- - ---! @brief Extract selector (s) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text The selector value. ---! @throws Exception if `s` is absent. -CREATE FUNCTION eql_v3.selector(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 's' THEN - RETURN val->>'s'; - END IF; - RAISE 'Expected a selector index (s) value in json: %', val; - END; -$$ LANGUAGE plpgsql; - ---! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK ---! guarantees `s` is present, so this is a simple field access. ---! @param entry eql_v3.jsonb_entry ---! @return text The selector value. -CREATE FUNCTION eql_v3.selector(entry eql_v3.jsonb_entry) - RETURNS text - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT entry ->> 's' -$$; - ------------------------------------------------------------------------------- --- Equality-term extractor (XOR-aware: coalesce(hm, oc)) ------------------------------------------------------------------------------- - ---! @brief XOR-aware equality term extractor for eql_v3.jsonb_entry. ---! ---! Returns the bytea of whichever deterministic term the sv entry carries — ---! `hm` (HMAC-256) or `oc` (CLLW ORE). The two byte distributions are disjoint ---! by construction, so byte equality on the coalesce is unambiguous. Canonical ---! equality extractor used by `=` / `<>` on jsonb_entry. ---! ---! @param entry eql_v3.jsonb_entry ---! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). -CREATE FUNCTION eql_v3.eq_term(entry eql_v3.jsonb_entry) - RETURNS bytea - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT decode(coalesce(entry ->> 'hm', entry ->> 'oc'), 'hex') -$$; - ------------------------------------------------------------------------------- --- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) ------------------------------------------------------------------------------- - ---! @brief Extract CLLW ORE index term from a ste_vec entry. ---! ---! `oc` is only ever present on an sv element, never at a root encrypted value, ---! so the typed overload accepts eql_v3.jsonb_entry. Returns SQL NULL when ---! `oc` is absent (btree NULL-filters such rows from range queries). ---! ---! @param entry eql_v3.jsonb_entry ---! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL. ---! @see eql_v3.has_ore_cllw -CREATE FUNCTION eql_v3.ore_cllw(entry eql_v3.jsonb_entry) - RETURNS eql_v3_internal.ore_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN entry ->> 'oc' IS NULL THEN NULL - ELSE ROW(decode(entry ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw - END -$$; - ---! @brief Check if a ste_vec entry contains a CLLW ORE index term. ---! @param entry eql_v3.jsonb_entry ---! @return boolean True if `oc` is present and non-null. -CREATE FUNCTION eql_v3.has_ore_cllw(entry eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT entry ->> 'oc' IS NOT NULL -$$; - ------------------------------------------------------------------------------- --- sv-array helpers ------------------------------------------------------------------------------- - ---! @brief Extract the sv element array as raw jsonb[]. ---! ---! Returns the elements of `sv` (or a single-element array wrapping the value ---! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. ---! ---! @param val jsonb encrypted EQL payload ---! @return jsonb[] Array of sv elements. -CREATE FUNCTION eql_v3.ste_vec(val jsonb) - RETURNS jsonb[] - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb; - ary jsonb[]; - BEGIN - IF val ? 'sv' THEN - sv := val->'sv'; - ELSE - sv := jsonb_build_array(val); - END IF; - - SELECT array_agg(elem) - INTO ary - FROM jsonb_array_elements(sv) AS elem; - - RETURN ary; - END; -$$ LANGUAGE plpgsql; - ---! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). ---! @param val jsonb encrypted EQL payload ---! @return boolean True if `a` is present and true. -CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'a' THEN - RETURN (val->>'a')::boolean; - END IF; - RETURN false; - END; -$$ LANGUAGE plpgsql; - ------------------------------------------------------------------------------- --- Deterministic-fields array for GIN containment ------------------------------------------------------------------------------- - ---! @brief Extract deterministic search fields (s, hm, oc, op) per sv element. ---! ---! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can ---! compare for containment. Use for GIN indexes and containment queries. ---! ---! @param val jsonb encrypted EQL payload ---! @return jsonb[] Array of objects with only deterministic fields. -CREATE FUNCTION eql_v3.jsonb_array(val jsonb) -RETURNS jsonb[] -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT ARRAY( - SELECT jsonb_object_agg(kv.key, kv.value) - FROM jsonb_array_elements( - CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END - ) AS elem, - LATERAL jsonb_each(elem) AS kv(key, value) - WHERE kv.key IN ('s', 'hm', 'oc', 'op') - GROUP BY elem - ); -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS - 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; - ------------------------------------------------------------------------------- --- Containment ------------------------------------------------------------------------------- - ---! @brief GIN-indexable containment check: does `a` contain all of `b`? ---! @param a jsonb Container payload. ---! @param b jsonb Search payload. ---! @return boolean True if a contains all deterministic elements of b. ---! @note Public raw-`jsonb[]` containment helper over the extracted ---! deterministic fields — the function-form entrypoint for containment on ---! platforms without operator support (Supabase/PostgREST). The typed ---! `eql_v3.json` `@>` operator does NOT call this function — it binds to ---! `eql_v3.ste_vec_contains` instead — but both agree on the result (a ---! parity test pins this). Also the documented GIN index expression ---! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. -CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; - ---! @brief GIN-indexable "is contained by" check. ---! @param a jsonb Payload to check. ---! @param b jsonb Container payload. ---! @return boolean True if all elements of a are contained in b. ---! @note Public raw-`jsonb[]` reverse-containment helper — the function-form ---! entrypoint for `<@` on platforms without operator support. The typed ---! `eql_v3.json` `<@` operator binds to `eql_v3.ste_vec_contains` instead, ---! but both agree on the result. -CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; - ---! @brief Check if an sv array contains a specific sv element. ---! ---! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, ---! oc)). This collapses the v2 hm/oc CASE: under the XOR contract both terms ---! are deterministic and byte-disjoint, so either one is a valid equality ---! discriminator and a single byte comparison is correct. ---! ---! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and oc byte ---! distributions never collide at a given selector. The crypto layer configures ---! a selector for eq XOR ordered, so both sides of a real comparison carry the ---! same term type; and an oc value carries a leading domain-tag byte an hm never ---! has. Unlike v2's explicit `has_hmac(both)`/`has_ore_cllw(both)`/`ELSE false` ---! CASE, this collapse would wrongly match an hm needle against an oc leaf if ---! their hex bytes were ever identical — which the contract prevents. The ---! negative-containment test guards against regression. ---! ---! @param a jsonb[] sv array to search within. ---! @param b jsonb sv element to search for. ---! @return boolean True if b is found in any element of a. -CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - result boolean; - _a jsonb; - BEGIN - result := false; - - FOR idx IN 1..array_length(a, 1) LOOP - _a := a[idx]; - result := result OR ( - eql_v3.selector(_a) = eql_v3.selector(b) - AND eql_v3.eq_term(_a::eql_v3.jsonb_entry) = eql_v3.eq_term(b::eql_v3.jsonb_entry) - ); - EXIT WHEN result; - END LOOP; - - RETURN result; - END; -$$ LANGUAGE plpgsql; - ---! @brief Does encrypted value `a` contain all sv elements of `b`? ---! ---! Empty b is always contained. Each element of b must match selector + eq_term ---! in some element of a. ---! ---! @param a eql_v3.json Container. ---! @param b eql_v3.json Elements to find. ---! @return boolean True if all elements of b are contained in a. ---! @see eql_v3.ste_vec_contains(jsonb[], jsonb) -CREATE FUNCTION eql_v3.ste_vec_contains(a eql_v3.json, b eql_v3.json) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - result boolean; - sv_a jsonb[]; - sv_b jsonb[]; - _b jsonb; - BEGIN - sv_a := eql_v3.ste_vec(a); - sv_b := eql_v3.ste_vec(b); - - IF array_length(sv_b, 1) IS NULL THEN - RETURN true; - END IF; - - IF array_length(sv_a, 1) IS NULL THEN - RETURN false; - END IF; - - result := true; - - FOR idx IN 1..array_length(sv_b, 1) LOOP - _b := sv_b[idx]; - result := result AND eql_v3.ste_vec_contains(sv_a, _b); - END LOOP; - - RETURN result; - END; -$$ LANGUAGE plpgsql; - ------------------------------------------------------------------------------- --- Path queries (text selector only) ------------------------------------------------------------------------------- - ---! @brief Query encrypted JSONB for sv elements matching `selector`. ---! ---! Returns one jsonb_entry row per matching encrypted element. Returns empty ---! set on no match. It deliberately does not wrap multiple matches as an ---! eql_v3.json document, because the root document domain requires an `sv` ---! array and single leaves belong to eql_v3.jsonb_entry. ---! ---! @param val jsonb encrypted EQL payload with `sv`. ---! @param selector text Selector hash (`s` value). ---! @return SETOF eql_v3.jsonb_entry Matching encrypted entries. ---! @see eql_v3.jsonb_path_query_first -CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) - RETURNS SETOF eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; - ---! @brief Check if a selector path exists in encrypted JSONB. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to test. ---! @return boolean True if a matching element exists. -CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT EXISTS ( - SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - ); -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; - ---! @brief Get the first sv element matching `selector`, or NULL. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to match. ---! @return eql_v3.jsonb_entry First matching element or NULL. -CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) - RETURNS eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - LIMIT 1 -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; - ------------------------------------------------------------------------------- --- Array functions ------------------------------------------------------------------------------- - ---! @brief Get the length of an encrypted JSONB array. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return integer Number of elements. ---! @throws Exception 'cannot get array length of a non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) - RETURNS integer - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF eql_v3_internal.is_ste_vec_array(val) THEN - sv := eql_v3.ste_vec(val); - RETURN array_length(sv, 1); - END IF; - - RAISE 'cannot get array length of a non-array'; - END; -$$ LANGUAGE plpgsql; - ---! @brief Extract elements of an encrypted JSONB array as rows. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF eql_v3.jsonb_entry One row per element (metadata preserved). ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) - RETURNS SETOF eql_v3.jsonb_entry - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - meta jsonb; - item jsonb; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; - - meta := eql_v3.meta_data(val); - sv := eql_v3.ste_vec(val); - - FOR idx IN 1..array_length(sv, 1) LOOP - item = sv[idx]; - RETURN NEXT (meta || item)::eql_v3.jsonb_entry; - END LOOP; - - RETURN; - END; -$$ LANGUAGE plpgsql; - ---! @brief Extract elements of an encrypted JSONB array as ciphertext text. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF text One ciphertext per element. ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) - RETURNS SETOF text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; - - sv := eql_v3.ste_vec(val); - - FOR idx IN 1..array_length(sv, 1) LOOP - RETURN NEXT eql_v3.ciphertext(sv[idx]); - END LOOP; - - RETURN; - END; -$$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE --- Source is src/v3/version.template - -DROP FUNCTION IF EXISTS eql_v3.version(); - ---! @file v3/version.sql ---! @brief EQL version reporting (self-contained eql_v3 surface) ---! ---! This file is auto-generated from src/v3/version.template during build. ---! The 3.0.0-alpha.2 placeholder is replaced with the actual release ---! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, ---! or "DEV" for development builds. - ---! @brief Get the installed EQL version string ---! ---! Returns the version string for the installed EQL library. This value is ---! baked in at build time from the release tag. ---! ---! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) ---! ---! @note Auto-generated during build from src/v3/version.template ---! ---! @example ---! -- Check installed EQL version ---! SELECT eql_v3.version(); ---! -- Returns: '3.0.0' -CREATE FUNCTION eql_v3.version() - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT '3.0.0-alpha.2'; -$$ LANGUAGE SQL; - ---! @brief Schema-level version marker for obj_description() discoverability ---! ---! Mirrors eql_v3.version() as a comment on the schema so the installed ---! version can also be read via obj_description('eql_v3'::regnamespace). -COMMENT ON SCHEMA eql_v3 IS '3.0.0-alpha.2'; - ---! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.timestamp_ord_ore. - ---! @brief State function for min on eql_v3.timestamp_ord_ore. ---! @param state eql_v3.timestamp_ord_ore ---! @param value eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) -RETURNS eql_v3.timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.timestamp_ord_ore. ---! @param input eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.timestamp_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.timestamp_ord_ore. ---! @param state eql_v3.timestamp_ord_ore ---! @param value eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) -RETURNS eql_v3.timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.timestamp_ord_ore. ---! @param input eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.timestamp_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.timestamp_ord_ope. - ---! @brief State function for min on eql_v3.timestamp_ord_ope. ---! @param state eql_v3.timestamp_ord_ope ---! @param value eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) -RETURNS eql_v3.timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.timestamp_ord_ope. ---! @param input eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.timestamp_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.timestamp_ord_ope. ---! @param state eql_v3.timestamp_ord_ope ---! @param value eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) -RETURNS eql_v3.timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.timestamp_ord_ope. ---! @param input eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.timestamp_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql ---! @brief Aggregates for eql_v3.timestamp_ord. - ---! @brief State function for min on eql_v3.timestamp_ord. ---! @param state eql_v3.timestamp_ord ---! @param value eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) -RETURNS eql_v3.timestamp_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.timestamp_ord. ---! @param input eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.timestamp_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.timestamp_ord. ---! @param state eql_v3.timestamp_ord ---! @param value eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) -RETURNS eql_v3.timestamp_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.timestamp_ord. ---! @param input eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.timestamp_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_operators.sql ---! @brief Operators for eql_v3.timestamp. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_eq_operators.sql ---! @brief Operators for eql_v3.timestamp_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_search_aggregates.sql ---! @brief Aggregates for eql_v3.text_search. - ---! @brief State function for min on eql_v3.text_search. ---! @param state eql_v3.text_search ---! @param value eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_search, value eql_v3.text_search) -RETURNS eql_v3.text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.text_search. ---! @param input eql_v3.text_search ---! @return eql_v3.text_search -CREATE AGGREGATE eql_v3.min(eql_v3.text_search) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_search, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.text_search. ---! @param state eql_v3.text_search ---! @param value eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_search, value eql_v3.text_search) -RETURNS eql_v3.text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.text_search. ---! @param input eql_v3.text_search ---! @return eql_v3.text_search -CREATE AGGREGATE eql_v3.max(eql_v3.text_search) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_search, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.text_ord_ore. - ---! @brief State function for min on eql_v3.text_ord_ore. ---! @param state eql_v3.text_ord_ore ---! @param value eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.text_ord_ore. ---! @param input eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.text_ord_ore. ---! @param state eql_v3.text_ord_ore ---! @param value eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.text_ord_ore. ---! @param input eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.text_ord_ope. - ---! @brief State function for min on eql_v3.text_ord_ope. ---! @param state eql_v3.text_ord_ope ---! @param value eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) -RETURNS eql_v3.text_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.text_ord_ope. ---! @param input eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.text_ord_ope. ---! @param state eql_v3.text_ord_ope ---! @param value eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) -RETURNS eql_v3.text_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.text_ord_ope. ---! @param input eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_aggregates.sql ---! @brief Aggregates for eql_v3.text_ord. - ---! @brief State function for min on eql_v3.text_ord. ---! @param state eql_v3.text_ord ---! @param value eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) -RETURNS eql_v3.text_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.text_ord. ---! @param input eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE AGGREGATE eql_v3.min(eql_v3.text_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.text_ord. ---! @param state eql_v3.text_ord ---! @param value eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) -RETURNS eql_v3.text_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.text_ord. ---! @param input eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE AGGREGATE eql_v3.max(eql_v3.text_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_operators.sql ---! @brief Operators for eql_v3.text. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_match_operators.sql ---! @brief Operators for eql_v3.text_match. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_match, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_match, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_match, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_eq_operators.sql ---! @brief Operators for eql_v3.text_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.smallint_ord_ore. - ---! @brief State function for min on eql_v3.smallint_ord_ore. ---! @param state eql_v3.smallint_ord_ore ---! @param value eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) -RETURNS eql_v3.smallint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.smallint_ord_ore. ---! @param input eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.smallint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.smallint_ord_ore. ---! @param state eql_v3.smallint_ord_ore ---! @param value eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) -RETURNS eql_v3.smallint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.smallint_ord_ore. ---! @param input eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.smallint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.smallint_ord_ope. - ---! @brief State function for min on eql_v3.smallint_ord_ope. ---! @param state eql_v3.smallint_ord_ope ---! @param value eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) -RETURNS eql_v3.smallint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.smallint_ord_ope. ---! @param input eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.smallint_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.smallint_ord_ope. ---! @param state eql_v3.smallint_ord_ope ---! @param value eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) -RETURNS eql_v3.smallint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.smallint_ord_ope. ---! @param input eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.smallint_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_aggregates.sql ---! @brief Aggregates for eql_v3.smallint_ord. - ---! @brief State function for min on eql_v3.smallint_ord. ---! @param state eql_v3.smallint_ord ---! @param value eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) -RETURNS eql_v3.smallint_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.smallint_ord. ---! @param input eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.smallint_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.smallint_ord. ---! @param state eql_v3.smallint_ord ---! @param value eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) -RETURNS eql_v3.smallint_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.smallint_ord. ---! @param input eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.smallint_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_operators.sql ---! @brief Operators for eql_v3.smallint. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_eq_operators.sql ---! @brief Operators for eql_v3.smallint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.real_ord_ore. - ---! @brief State function for min on eql_v3.real_ord_ore. ---! @param state eql_v3.real_ord_ore ---! @param value eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) -RETURNS eql_v3.real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.real_ord_ore. ---! @param input eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.real_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.real_ord_ore. ---! @param state eql_v3.real_ord_ore ---! @param value eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) -RETURNS eql_v3.real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.real_ord_ore. ---! @param input eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.real_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.real_ord_ope. - ---! @brief State function for min on eql_v3.real_ord_ope. ---! @param state eql_v3.real_ord_ope ---! @param value eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) -RETURNS eql_v3.real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.real_ord_ope. ---! @param input eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.real_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.real_ord_ope. ---! @param state eql_v3.real_ord_ope ---! @param value eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) -RETURNS eql_v3.real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.real_ord_ope. ---! @param input eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.real_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_aggregates.sql ---! @brief Aggregates for eql_v3.real_ord. - ---! @brief State function for min on eql_v3.real_ord. ---! @param state eql_v3.real_ord ---! @param value eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) -RETURNS eql_v3.real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.real_ord. ---! @param input eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE AGGREGATE eql_v3.min(eql_v3.real_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.real_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.real_ord. ---! @param state eql_v3.real_ord ---! @param value eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) -RETURNS eql_v3.real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.real_ord. ---! @param input eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE AGGREGATE eql_v3.max(eql_v3.real_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.real_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_operators.sql ---! @brief Operators for eql_v3.real. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_eq_operators.sql ---! @brief Operators for eql_v3.real_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.numeric_ord_ore. - ---! @brief State function for min on eql_v3.numeric_ord_ore. ---! @param state eql_v3.numeric_ord_ore ---! @param value eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) -RETURNS eql_v3.numeric_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.numeric_ord_ore. ---! @param input eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.numeric_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.numeric_ord_ore. ---! @param state eql_v3.numeric_ord_ore ---! @param value eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) -RETURNS eql_v3.numeric_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.numeric_ord_ore. ---! @param input eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.numeric_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.numeric_ord_ope. - ---! @brief State function for min on eql_v3.numeric_ord_ope. ---! @param state eql_v3.numeric_ord_ope ---! @param value eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) -RETURNS eql_v3.numeric_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.numeric_ord_ope. ---! @param input eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.numeric_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.numeric_ord_ope. ---! @param state eql_v3.numeric_ord_ope ---! @param value eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) -RETURNS eql_v3.numeric_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.numeric_ord_ope. ---! @param input eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.numeric_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_aggregates.sql ---! @brief Aggregates for eql_v3.numeric_ord. - ---! @brief State function for min on eql_v3.numeric_ord. ---! @param state eql_v3.numeric_ord ---! @param value eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) -RETURNS eql_v3.numeric_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.numeric_ord. ---! @param input eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.numeric_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.numeric_ord. ---! @param state eql_v3.numeric_ord ---! @param value eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) -RETURNS eql_v3.numeric_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.numeric_ord. ---! @param input eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.numeric_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_operators.sql ---! @brief Operators for eql_v3.numeric. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_eq_operators.sql ---! @brief Operators for eql_v3.numeric_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.integer_ord_ore. - ---! @brief State function for min on eql_v3.integer_ord_ore. ---! @param state eql_v3.integer_ord_ore ---! @param value eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) -RETURNS eql_v3.integer_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.integer_ord_ore. ---! @param input eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.integer_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.integer_ord_ore. ---! @param state eql_v3.integer_ord_ore ---! @param value eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) -RETURNS eql_v3.integer_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.integer_ord_ore. ---! @param input eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.integer_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.integer_ord_ope. - ---! @brief State function for min on eql_v3.integer_ord_ope. ---! @param state eql_v3.integer_ord_ope ---! @param value eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) -RETURNS eql_v3.integer_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.integer_ord_ope. ---! @param input eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.integer_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.integer_ord_ope. ---! @param state eql_v3.integer_ord_ope ---! @param value eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) -RETURNS eql_v3.integer_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.integer_ord_ope. ---! @param input eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.integer_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_aggregates.sql ---! @brief Aggregates for eql_v3.integer_ord. - ---! @brief State function for min on eql_v3.integer_ord. ---! @param state eql_v3.integer_ord ---! @param value eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) -RETURNS eql_v3.integer_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.integer_ord. ---! @param input eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.integer_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.integer_ord. ---! @param state eql_v3.integer_ord ---! @param value eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) -RETURNS eql_v3.integer_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.integer_ord. ---! @param input eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.integer_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_operators.sql ---! @brief Operators for eql_v3.integer. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_eq_operators.sql ---! @brief Operators for eql_v3.integer_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.double_ord_ore. - ---! @brief State function for min on eql_v3.double_ord_ore. ---! @param state eql_v3.double_ord_ore ---! @param value eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) -RETURNS eql_v3.double_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.double_ord_ore. ---! @param input eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.double_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.double_ord_ore. ---! @param state eql_v3.double_ord_ore ---! @param value eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) -RETURNS eql_v3.double_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.double_ord_ore. ---! @param input eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.double_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.double_ord_ope. - ---! @brief State function for min on eql_v3.double_ord_ope. ---! @param state eql_v3.double_ord_ope ---! @param value eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) -RETURNS eql_v3.double_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.double_ord_ope. ---! @param input eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.double_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.double_ord_ope. ---! @param state eql_v3.double_ord_ope ---! @param value eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) -RETURNS eql_v3.double_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.double_ord_ope. ---! @param input eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.double_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_aggregates.sql ---! @brief Aggregates for eql_v3.double_ord. - ---! @brief State function for min on eql_v3.double_ord. ---! @param state eql_v3.double_ord ---! @param value eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) -RETURNS eql_v3.double_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.double_ord. ---! @param input eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE AGGREGATE eql_v3.min(eql_v3.double_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.double_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.double_ord. ---! @param state eql_v3.double_ord ---! @param value eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) -RETURNS eql_v3.double_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.double_ord. ---! @param input eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE AGGREGATE eql_v3.max(eql_v3.double_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.double_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_operators.sql ---! @brief Operators for eql_v3.double. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_eq_operators.sql ---! @brief Operators for eql_v3.double_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.date_ord_ore. - ---! @brief State function for min on eql_v3.date_ord_ore. ---! @param state eql_v3.date_ord_ore ---! @param value eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) -RETURNS eql_v3.date_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.date_ord_ore. ---! @param input eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.date_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.date_ord_ore. ---! @param state eql_v3.date_ord_ore ---! @param value eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) -RETURNS eql_v3.date_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.date_ord_ore. ---! @param input eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.date_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.date_ord_ope. - ---! @brief State function for min on eql_v3.date_ord_ope. ---! @param state eql_v3.date_ord_ope ---! @param value eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) -RETURNS eql_v3.date_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.date_ord_ope. ---! @param input eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.date_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.date_ord_ope. ---! @param state eql_v3.date_ord_ope ---! @param value eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) -RETURNS eql_v3.date_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.date_ord_ope. ---! @param input eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.date_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_aggregates.sql ---! @brief Aggregates for eql_v3.date_ord. - ---! @brief State function for min on eql_v3.date_ord. ---! @param state eql_v3.date_ord ---! @param value eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) -RETURNS eql_v3.date_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.date_ord. ---! @param input eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE AGGREGATE eql_v3.min(eql_v3.date_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.date_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.date_ord. ---! @param state eql_v3.date_ord ---! @param value eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) -RETURNS eql_v3.date_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.date_ord. ---! @param input eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE AGGREGATE eql_v3.max(eql_v3.date_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.date_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_operators.sql ---! @brief Operators for eql_v3.date. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_eq_operators.sql ---! @brief Operators for eql_v3.date_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/boolean/boolean_operators.sql ---! @brief Operators for eql_v3.boolean. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.boolean, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.boolean, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.boolean, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.boolean, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.boolean, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.boolean, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.boolean, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.bigint_ord_ore. - ---! @brief State function for min on eql_v3.bigint_ord_ore. ---! @param state eql_v3.bigint_ord_ore ---! @param value eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) -RETURNS eql_v3.bigint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.bigint_ord_ore. ---! @param input eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.bigint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.bigint_ord_ore. ---! @param state eql_v3.bigint_ord_ore ---! @param value eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) -RETURNS eql_v3.bigint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.bigint_ord_ore. ---! @param input eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.bigint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.bigint_ord_ope. - ---! @brief State function for min on eql_v3.bigint_ord_ope. ---! @param state eql_v3.bigint_ord_ope ---! @param value eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) -RETURNS eql_v3.bigint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.bigint_ord_ope. ---! @param input eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.bigint_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.bigint_ord_ope. ---! @param state eql_v3.bigint_ord_ope ---! @param value eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) -RETURNS eql_v3.bigint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.bigint_ord_ope. ---! @param input eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.bigint_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_aggregates.sql ---! @brief Aggregates for eql_v3.bigint_ord. - ---! @brief State function for min on eql_v3.bigint_ord. ---! @param state eql_v3.bigint_ord ---! @param value eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) -RETURNS eql_v3.bigint_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.bigint_ord. ---! @param input eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.bigint_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.bigint_ord. ---! @param state eql_v3.bigint_ord ---! @param value eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) -RETURNS eql_v3.bigint_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.bigint_ord. ---! @param input eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.bigint_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_operators.sql ---! @brief Operators for eql_v3.bigint. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_eq_operators.sql ---! @brief Operators for eql_v3.bigint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - ---! @brief EQL lint: detect non-inlinable operator implementation functions ---! ---! Returns one row per violation found in the installed `eql_v3` surface. The ---! Postgres planner can only inline a function during index matching when: ---! ---! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined) ---! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into ---! index expressions) ---! * No `SET` clauses (e.g. `SET search_path = ...`) ---! * Not `SECURITY DEFINER` ---! * Single-statement SELECT body ---! ---! @note The single-statement SELECT body condition is **not yet checked** by ---! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE, ---! or any pre-SELECT statement will pass all four implemented checks while ---! remaining non-inlinable. Implementing the check requires walking `prosrc` ---! (or `pg_get_functiondef`); tracked as a follow-up. ---! ---! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and ---! the SEM index-term types `eql_v3_internal.ore_block_256`, `eql_v3_internal.ore_cllw`) whose ---! implementation functions fail any of these rules silently fall back to seq ---! scan when the documented functional indexes (`eql_v3.eq_term(col)`, ---! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. ---! ---! Severity: ---! `error` — fixable, blocks index matching, ship-blocking. ---! `warning` — likely-fixable, may not block matching but signals intent. ---! `info` — observational; useful for review, not a defect on its own. ---! ---! Categories: ---! `inlinability_language` — implementation function isn't `LANGUAGE sql`. ---! `inlinability_volatility` — implementation function is VOLATILE. ---! `inlinability_set_clause` — implementation function has a `SET` clause. ---! `inlinability_secdef` — implementation function is `SECURITY DEFINER`. ---! `inlinability_transitive` — implementation function is itself inlinable ---! but its body invokes a non-inlinable function ---! (depth 1; the planner can't peek through ---! that boundary). ---! `blocker_language` — encrypted-domain blocker is not LANGUAGE ---! plpgsql. The planner can inline / elide a ---! LANGUAGE sql body when the result is ---! provably unused, silently bypassing the ---! RAISE that the blocker exists to perform. ---! `blocker_strict` — encrypted-domain blocker is STRICT. ---! PostgreSQL skips the body and returns NULL ---! on NULL arguments, silently bypassing the ---! RAISE. ---! `domain_over_domain` — an `eql_v3` encrypted domain is derived from ---! another encrypted domain rather than jsonb. ---! Operators resolve against the ultimate base ---! type, so the derived domain does not ---! inherit the base domain's blocker surface. ---! `domain_opclass` — an operator class is declared FOR TYPE on an ---! `eql_v3` encrypted domain. Opclasses on ---! domains bypass operator resolution; use a ---! functional index on the extractor instead. ---! `schema_placement` — a naked composite or enum TYPE lives in the ---! public `eql_v3` schema. Internal index-term ---! types (e.g. `ore_block_256_term`) belong in ---! `eql_v3_internal`; a composite/enum in ---! `eql_v3` clutters the Supabase Table Builder ---! type picker, which the schema split exists to ---! prevent. Move it to `eql_v3_internal`. ---! ---! @example ---! ``` ---! SELECT severity, category, object_name, message ---! FROM eql_v3.lints() ---! WHERE severity = 'error' ---! ORDER BY category, object_name; ---! ``` ---! ---! @return SETOF record (severity text, category text, object_name text, message text) -CREATE OR REPLACE FUNCTION eql_v3.lints() -RETURNS TABLE ( - severity text, - category text, - object_name text, - message text -) -LANGUAGE sql STABLE -AS $$ - WITH - -- All operators where at least one operand is an `eql_v3` type. Limits - -- the scope of the lint to the operator surface customers actually hit - -- via SQL (`col = val`, `col @> '...'` and friends). - eql_operators AS ( - SELECT - op.oid AS oprid, - op.oprname AS opname, - op.oprcode AS implfunc, - op.oprleft::regtype AS lhs, - op.oprright::regtype AS rhs, - op.oprcode::regprocedure AS impl_signature - FROM pg_operator op - WHERE EXISTS ( - SELECT 1 FROM pg_type t - WHERE t.oid IN (op.oprleft, op.oprright) - AND t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) - ) - ), - - -- Cross-join with each operator's implementation function metadata. - -- One row per operator; columns describe the inlinability of the impl. - op_impl AS ( - SELECT - eo.opname, - eo.lhs, - eo.rhs, - eo.implfunc AS impl_oid, - eo.impl_signature::text AS impl_signature, - lang_l.lanname AS lang, - p.provolatile AS volatility, - p.proconfig AS config, - p.prosecdef AS secdef, - p.prosrc AS body - FROM eql_operators eo - JOIN pg_proc p ON p.oid = eo.implfunc - JOIN pg_language lang_l ON lang_l.oid = p.prolang - ), - - -- Encrypted-domain blockers: functions in `eql_v3` whose body contains - -- a blocker marker emitted by the codegen (any of the - -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean - -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the - -- literal `is not supported for` for older path-operator blockers) AND - -- that take at least one `eql_v3` domain over jsonb argument. The argument - -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` - -- helpers themselves, which contain the marker in their body but are not - -- blockers (they take text arguments, not a domain). - encrypted_domain_blockers AS ( - SELECT - p.oid AS oid, - p.oid::regprocedure::text AS signature, - lang_l.lanname AS lang, - p.proisstrict AS isstrict - FROM pg_catalog.pg_proc p - JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) - AND (p.prosrc LIKE '%encrypted_domain_unsupported%' - OR p.prosrc LIKE '%is not supported for%') - AND EXISTS ( - SELECT 1 - FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) - JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - WHERE dt.typtype = 'd' - AND bt.typname = 'jsonb' - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) - ) - ) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Direct inlinability checks: each row examines one operator's │ - -- │ implementation function and emits a violation if any rule is │ - -- │ broken. Multiple violations on the same function become │ - -- │ multiple rows (developers see every reason it doesn't inline). │ - -- └─────────────────────────────────────────────────────────────────┘ - - SELECT - 'error' AS severity, - 'inlinability_language' AS category, - format('operator %s(%s, %s) -> %s', - opname, lhs, rhs, impl_signature) AS object_name, - format( - 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.', - lang, opname) AS message - FROM op_impl - WHERE lang <> 'sql' - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) - - UNION ALL - - SELECT - 'error', - 'inlinability_volatility', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).', - opname) - FROM op_impl - WHERE volatility = 'v' - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) - - UNION ALL - - SELECT - 'error', - 'inlinability_set_clause', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.') - FROM op_impl - WHERE config IS NOT NULL - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) - - UNION ALL - - SELECT - 'error', - 'inlinability_secdef', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.' - FROM op_impl - WHERE secdef - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Transitive inlinability: an operator implementation function │ - -- │ that's itself inlinable can still fail to inline if its body │ - -- │ calls a non-inlinable function. Walk one level via pg_depend. │ - -- │ │ - -- │ Postgres records function-to-function dependencies in │ - -- │ pg_depend with deptype 'n' (normal) when one function references│ - -- │ another in its body — but only at CREATE time and only for │ - -- │ direct calls. This is good enough for v1; deeper transitive │ - -- │ analysis is a follow-up. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'inlinability_transitive', - format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs, - oi.impl_signature), - format( - 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.', - called.proname, - called_lang.lanname, - CASE called.provolatile - WHEN 'i' THEN 'IMMUTABLE' - WHEN 's' THEN 'STABLE' - WHEN 'v' THEN 'VOLATILE' - END, - CASE WHEN called.proconfig IS NOT NULL - THEN ', has SET clause' - ELSE '' END) - FROM op_impl oi - -- Only worth the transitive check if the outer function is otherwise - -- inlinable — otherwise the direct lints above already report it. - JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure - JOIN pg_depend d - ON d.classid = 'pg_proc'::regclass - AND d.objid = outer_p.oid - AND d.refclassid = 'pg_proc'::regclass - AND d.deptype = 'n' - JOIN pg_proc called ON called.oid = d.refobjid - JOIN pg_language called_lang ON called_lang.oid = called.prolang - WHERE oi.lang = 'sql' - AND oi.volatility IN ('i', 's') - AND oi.config IS NULL - AND NOT oi.secdef - AND called.oid <> outer_p.oid - AND ( - called_lang.lanname <> 'sql' - OR called.provolatile = 'v' - OR called.proconfig IS NOT NULL - OR called.prosecdef - ) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │ - -- │ have inverted inlinability requirements vs operator impls. │ - -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │ - -- │ blocker returns NULL on NULL args. Both silently re-enable │ - -- │ operators the storage variant is supposed to block. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'blocker_language', - format('function %s', signature), - format( - 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.', - lang) - FROM encrypted_domain_blockers - WHERE lang <> 'plpgsql' - - UNION ALL - - SELECT - 'error', - 'blocker_strict', - format('function %s', signature), - 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.' - FROM encrypted_domain_blockers - WHERE isstrict - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain identity: an encrypted-domain must be defined directly │ - -- │ over jsonb. Operators resolve against the ultimate base type, │ - -- │ so domain-over-domain inherits jsonb's operator surface and not │ - -- │ the base domain's blockers. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'domain_over_domain', - format('domain %I.%I', dn.nspname, dt.typname), - format( - 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.', - dn.nspname, dt.typname, bn.nspname, bt.typname) - FROM pg_catalog.pg_type dt - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace - WHERE dt.typtype = 'd' - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) - AND bt.typtype = 'd' - AND bn.nspname = ANY(eql_v3_internal.owned_schemas()) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain opclass: an operator class declared FOR TYPE on an │ - -- │ encrypted-domain bypasses operator resolution at index time. │ - -- │ Use a functional index on the extractor instead. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'domain_opclass', - format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname), - format( - 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.', - cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname) - FROM pg_catalog.pg_opclass oc - JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype - JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace - JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace - WHERE t.typtype = 'd' - AND tn.nspname = ANY(eql_v3_internal.owned_schemas()) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Schema placement: the public `eql_v3` schema must hold only the │ - -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │ - -- │ there is an internal index-term type in the wrong schema — it │ - -- │ clutters the Supabase type picker the split exists to keep clean. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'schema_placement', - format('type %I.%I', n.nspname, t.typname), - format( - 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.', - n.nspname, t.typname, - CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END) - FROM pg_catalog.pg_type t - JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace - WHERE n.nspname = 'eql_v3' - AND t.typtype IN ('c', 'e') - - ORDER BY 1, 2, 3; -$$; - -COMMENT ON FUNCTION eql_v3.lints() IS - 'EQL lint: returns one row per non-inlinable operator implementation. ' - 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a ' - 'CI-gateable check that all operator implementations on eql_v3 types are ' - 'eligible for planner inlining.'; - ---! @file v3/jsonb/operators.sql ---! @brief Operators on eql_v3.json and eql_v3.jsonb_entry. - ------------------------------------------------------------------------------- --- -> field accessor (returns jsonb_entry) ------------------------------------------------------------------------------- - ---! @brief -> operator with text selector. ---! ---! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged ---! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to ---! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional ---! index on `eql_v3.eq_term(col -> 'sel')`. ---! ---! @warning The selector operand MUST carry a known type — a text-typed ---! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::text`). ---! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> text` ---! operator and silently returns native jsonb semantics (a root-key lookup, ---! typically NULL), NOT this operator: PostgreSQL reduces the `eql_v3.json` ---! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the ---! native base-type operator wins the exact-match tiebreak. This is intrinsic to ---! the domain type-kind and applies to the native-jsonb blockers too. See ---! the "Typed operands" caveat in docs/reference/json-support.md. ---! ---! @param e eql_v3.json Root encrypted payload. ---! @param selector text Selector hash. ---! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector text) - RETURNS eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT ( - eql_v3.meta_data(e) || - jsonb_path_query_first( - e, - '$.sv[*] ? (@.s == $sel)'::jsonpath, - jsonb_build_object('sel', selector) - ) - )::eql_v3.jsonb_entry -$$; - -CREATE OPERATOR ->( - FUNCTION=eql_v3."->", - LEFTARG=eql_v3.json, - RIGHTARG=text -); - ---! @brief -> operator with integer array index (0-based, JSONB convention). ---! @param e eql_v3.json Encrypted sv-array payload. ---! @param selector integer Array index. ---! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector integer) - RETURNS eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE - WHEN eql_v3_internal.is_ste_vec_array(e) THEN - -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an - -- unknown-typed literal, so `e -> 'sv'` already flattens `eql_v3.json` to - -- its base type and binds native `jsonb -> text` (see the @warning above) — - -- the custom `->(eql_v3.json, text)` operator does NOT capture a bare - -- untyped literal. The cast documents that intent and guards the `-> selector` - -- (integer) hop from ever resolving to the v3 `->(eql_v3.json, integer)` - -- operator instead of native array access. - (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::eql_v3.jsonb_entry - ELSE NULL - END -$$; - -CREATE OPERATOR ->( - FUNCTION=eql_v3."->", - LEFTARG=eql_v3.json, - RIGHTARG=integer -); - ------------------------------------------------------------------------------- --- ->> field accessor (alias of -> coerced to text) ------------------------------------------------------------------------------- - ---! @brief ->> operator with text selector. Inlinable alias of -> coerced to ---! text. ---! ---! Intentional v2 parity: this serializes the entire matched jsonb_entry ---! object as JSON text. It does not decrypt or return scalar plaintext like ---! native `jsonb ->>`. ---! @param e eql_v3.json Encrypted payload. ---! @param selector text Field selector hash. ---! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector text) - RETURNS text - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3."->"(e, selector)::jsonb::text -$$; - -CREATE OPERATOR ->> ( - FUNCTION=eql_v3."->>", - LEFTARG=eql_v3.json, - RIGHTARG=text -); - ---! @brief ->> operator with integer array index. Inlinable alias of ---! ->(json, integer) coerced to text. ---! @param e eql_v3.json Encrypted sv-array payload. ---! @param selector integer Array index. ---! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector integer) - RETURNS text - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3."->"(e, selector)::jsonb::text -$$; - -CREATE OPERATOR ->> ( - FUNCTION=eql_v3."->>", - LEFTARG=eql_v3.json, - RIGHTARG=integer -); - ------------------------------------------------------------------------------- --- @> containment ------------------------------------------------------------------------------- - ---! @brief @> contains operator (document, document). ---! @param a eql_v3.json Container. ---! @param b eql_v3.json Contained value. ---! @return boolean True if a contains b. ---! @see eql_v3.ste_vec_contains -CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.json) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ste_vec_contains(a, b) -$$; - -CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.json -); - ---! @brief @> contains operator with an jsonb_query needle. ---! ---! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a ---! functional GIN index on the same expression engages. ---! ---! @param a eql_v3.json Container. ---! @param b eql_v3.jsonb_query Query payload. ---! @return boolean True if a contains b. -CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_query) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb -$$; - -CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.jsonb_query -); - ---! @brief @> contains operator with a single jsonb_entry needle. ---! ---! Wraps the entry into a single-element sv array (stripping `c`) and reduces ---! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form. ---! ---! @param a eql_v3.json Container. ---! @param b eql_v3.jsonb_entry Single entry. ---! @return boolean True if a contains an sv entry matching b. -CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_entry) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.to_ste_vec_query(a)::jsonb - @> jsonb_build_object( - 'sv', - jsonb_build_array( - jsonb_strip_nulls( - jsonb_build_object( - 's', b -> 's', - 'hm', b -> 'hm', - 'oc', b -> 'oc' - ) - ) - ) - ) -$$; - -CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.jsonb_entry -); - ------------------------------------------------------------------------------- --- <@ contained-by (reverse of @>) ------------------------------------------------------------------------------- - ---! @brief <@ contained-by operator (document, document). ---! @param a eql_v3.json Contained value. ---! @param b eql_v3.json Container. ---! @return boolean True if a is contained by b. -CREATE FUNCTION eql_v3."<@"(a eql_v3.json, b eql_v3.json) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ste_vec_contains(b, a) -$$; - -CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.json -); - ---! @brief <@ contained-by operator with an jsonb_query LHS. ---! @param a eql_v3.jsonb_query Query payload. ---! @param b eql_v3.json Container. ---! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_query, b eql_v3.json) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3."@>"(b, a) -$$; - -CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.jsonb_query, - RIGHTARG=eql_v3.json -); - ---! @brief <@ contained-by operator with a jsonb_entry LHS. ---! @param a eql_v3.jsonb_entry Single entry. ---! @param b eql_v3.json Container. ---! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_entry, b eql_v3.json) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3."@>"(b, a) -$$; - -CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.jsonb_entry, - RIGHTARG=eql_v3.json -); - ------------------------------------------------------------------------------- --- jsonb_entry comparisons ------------------------------------------------------------------------------- - ---! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if the entries are equal -CREATE FUNCTION eql_v3.eq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) -$$; - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = =, - NEGATOR = <>, - RESTRICT = eqsel, - JOIN = eqjoinsel -); - ---! @brief Inequality on jsonb_entry via eq_term. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if the entries are not equal -CREATE FUNCTION eql_v3.neq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) -$$; - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = <>, - NEGATOR = =, - RESTRICT = neqsel, - JOIN = neqjoinsel -); - ---! @brief Less-than on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if a is less than b -CREATE FUNCTION eql_v3.lt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ore_cllw(a) < eql_v3.ore_cllw(b) -$$; - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = >, - NEGATOR = >=, - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel -); - ---! @brief Less-than-or-equal on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if a is less than or equal to b -CREATE FUNCTION eql_v3.lte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ore_cllw(a) <= eql_v3.ore_cllw(b) -$$; - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = >=, - NEGATOR = >, - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel -); - ---! @brief Greater-than on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if a is greater than b -CREATE FUNCTION eql_v3.gt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ore_cllw(a) > eql_v3.ore_cllw(b) -$$; - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = <, - NEGATOR = <=, - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel -); - ---! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if a is greater than or equal to b -CREATE FUNCTION eql_v3.gte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ore_cllw(a) >= eql_v3.ore_cllw(b) -$$; - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = <=, - NEGATOR = <, - RESTRICT = scalargesel, - JOIN = scalargejoinsel -); - ---! @file v3/jsonb/blockers.sql ---! @brief Native-jsonb firewall for eql_v3.json. ---! ---! eql_v3.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons ---! = <> < <= > >= are supported on eql_v3.jsonb_entry only, not on the root ---! document domain. ---! Every OTHER native jsonb operator reachable via domain fallback against the ---! base type jsonb is BLOCKED here so an encrypted column can never silently ---! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS ---! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||. ---! ---! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let ---! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the ---! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_* ---! helpers. Each blocker's RETURNS type matches the native operator it shadows ---! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a ---! composed expression resolves and the body raises 'operator not supported', ---! rather than failing earlier with a misleading 'operator does not exist' on a ---! boolean intermediate. The bound operator must resolve before native fallback, ---! so the firewall fires. - ---! @brief Blocker: ? (key/element exists). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a eql_v3.json, b text) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal.jsonb_blocked_exists, - LEFTARG = eql_v3.json, - RIGHTARG = text -); - ---! @brief Blocker: ?| (any key exists). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a eql_v3.json, b text[]) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?|'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: ?& (all keys exist). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a eql_v3.json, b text[]) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?&'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: @? (jsonpath exists). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonpath Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a eql_v3.json, b jsonpath) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@?'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, - LEFTARG = eql_v3.json, - RIGHTARG = jsonpath -); - ---! @brief Blocker: @@ (jsonpath predicate). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonpath Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a eql_v3.json, b jsonpath) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@@'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, - LEFTARG = eql_v3.json, - RIGHTARG = jsonpath -); - ---! @brief Blocker: #> (path extract, native returns jsonb). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a eql_v3.json, b text[]) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#>'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: #>> (path extract as text). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return text Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a eql_v3.json, b text[]) -RETURNS text -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_text('eql_v3.json', '#>>'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: - (delete key, text RHS; native returns jsonb). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a eql_v3.json, b text) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, - LEFTARG = eql_v3.json, - RIGHTARG = text -); - ---! @brief Blocker: - (delete index, integer RHS). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b integer Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a eql_v3.json, b integer) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, - LEFTARG = eql_v3.json, - RIGHTARG = integer -); - ---! @brief Blocker: - (delete keys, text[] RHS). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a eql_v3.json, b text[]) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: #- (delete at path). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a eql_v3.json, b text[]) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#-'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: || (concatenate, encrypted on the left). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonb Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a eql_v3.json, b jsonb) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal.jsonb_blocked_concat, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - ---! @brief Blocker: || (concatenate, encrypted on the right). ---! @param a jsonb Native LHS operand. ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b eql_v3.json) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - ------------------------------------------------------------------------------- --- Root-document comparison blockers. ------------------------------------------------------------------------------- - ---! @brief Blocker: root eql_v3.json document comparisons. ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a eql_v3.json, b eql_v3.json) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: root eql_v3.json-to-jsonb comparisons. ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonb Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a eql_v3.json, b jsonb) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: root jsonb-to-eql_v3.json comparisons. ---! @param a jsonb Native LHS operand. ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b eql_v3.json) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - ------------------------------------------------------------------------------- --- Mixed jsonb containment blockers. ------------------------------------------------------------------------------- - ---! @brief Blocker: @> with encrypted root document and native jsonb. ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonb Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a eql_v3.json, b jsonb) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: @> with native jsonb and encrypted root document. ---! @param a jsonb Native LHS operand. ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b eql_v3.json) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: <@ with encrypted root document and native jsonb. ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonb Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a eql_v3.json, b jsonb) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: <@ with native jsonb and encrypted root document. ---! @param a jsonb Native LHS operand. ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b eql_v3.json) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - ---! @file v3/jsonb/aggregates.sql ---! @brief min / max aggregates over eql_v3.jsonb_entry. ---! ---! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by ---! their CLLW ORE (`oc`) term, so the extremum is picked by comparing ---! `eql_v3.ore_cllw(entry)` rather than the scalar Block-ORE `ord_term` the ---! generated scalar ord aggregates use. Same STRICT + PARALLEL SAFE shape as the ---! generated scalar `min`/`max` so partial/parallel aggregation is available on ---! large GROUP BY workloads. ---! ---! Per the encrypted-domain footgun rules the state functions are ---! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would ---! be inlinable and the planner could elide it. ---! ---! @note **Only `oc`-carrying entries are orderable.** `eql_v3.ore_cllw(entry)` ---! returns NULL when an entry has no `oc` (CLLW ORE) term — the same entries a ---! `eql_v3.ore_cllw` btree NULL-filters from range scans. The state functions ---! therefore IGNORE `oc`-less entries (they never become or survive as the ---! extremum), so `min`/`max` is well-defined over a mix of `oc`-carrying and ---! `oc`-less entries and is not corrupted by an `oc`-less seed. A naive ---! `ore_cllw(value) < ore_cllw(state)` would be NULL whenever either side ---! lacks `oc`, pinning a wrong (`oc`-less) extremum when the first aggregated ---! row is `oc`-less. An all-`oc`-less input has no orderable extremum and ---! returns the (arbitrary) STRICT seed. - ---! @brief State function for min on eql_v3.jsonb_entry. ---! ---! Keeps whichever orderable entry has the lesser CLLW ORE term. STRICT, so SQL ---! NULL entries are skipped by the aggregate machinery; `oc`-less (non-orderable) ---! entries are skipped explicitly (see the @note on this file). ---! ---! @param state eql_v3.jsonb_entry Running extremum. ---! @param value eql_v3.jsonb_entry Candidate entry. ---! @return eql_v3.jsonb_entry The lesser orderable entry by `ore_cllw`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( - state eql_v3.jsonb_entry, - value eql_v3.jsonb_entry -) -RETURNS eql_v3.jsonb_entry -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); - state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); -BEGIN - -- A non-orderable (oc-less) candidate never replaces the running extremum. - IF value_ore IS NULL THEN - RETURN state; - END IF; - -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an oc-less STRICT seed) or strictly greater. - IF state_ore IS NULL OR value_ore < state_ore THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate over eql_v3.jsonb_entry. ---! @param input eql_v3.jsonb_entry ---! @return eql_v3.jsonb_entry The entry with the smallest CLLW ORE term. -CREATE AGGREGATE eql_v3.min(eql_v3.jsonb_entry) ( - sfunc = eql_v3_internal.jsonb_entry_min_sfunc, - stype = eql_v3.jsonb_entry, - combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.jsonb_entry. ---! ---! Keeps whichever orderable entry has the greater CLLW ORE term. `oc`-less ---! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). ---! ---! @param state eql_v3.jsonb_entry Running extremum. ---! @param value eql_v3.jsonb_entry Candidate entry. ---! @return eql_v3.jsonb_entry The greater orderable entry by `ore_cllw`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( - state eql_v3.jsonb_entry, - value eql_v3.jsonb_entry -) -RETURNS eql_v3.jsonb_entry -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); - state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); -BEGIN - -- A non-orderable (oc-less) candidate never replaces the running extremum. - IF value_ore IS NULL THEN - RETURN state; - END IF; - -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an oc-less STRICT seed) or strictly lesser. - IF state_ore IS NULL OR value_ore > state_ore THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate over eql_v3.jsonb_entry. ---! @param input eql_v3.jsonb_entry ---! @return eql_v3.jsonb_entry The entry with the largest CLLW ORE term. -CREATE AGGREGATE eql_v3.max(eql_v3.jsonb_entry) ( - sfunc = eql_v3_internal.jsonb_entry_max_sfunc, - stype = eql_v3.jsonb_entry, - combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, - parallel = safe -); ---! @file pin_search_path_v3.sql ---! @brief Post-install: pin search_path on every eql_v3.* function. ---! ---! Appended verbatim by `tasks/build.sh` to the end of the v3-only release ---! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives ---! outside src/ so it stays out of the dependency graph. ---! ---! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and ---! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`, ---! satisfying Supabase splinter's `function_search_path_mutable` lint. ---! ---! @note A SET clause disables SQL-function inlining. The inline-critical SEM ---! helpers (ore_block_256_*, ore_cllw_*, ore_cllw/has_ore_cllw, ---! ope_cllw, hmac_256, bloom_filter over jsonb) and the ---! encrypted-domain family (recognised structurally) are deliberately ---! left unpinned. ---! @see tasks/test/splinter.sh ---! @see tasks/build.sh - -DO $$ -DECLARE - fn_oid oid; - inline_critical_oids oid[]; - jsonb_oid oid; -BEGIN - SELECT t.oid INTO jsonb_oid - FROM pg_catalog.pg_type t - JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace - WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb'; - - IF jsonb_oid IS NULL THEN - RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found'; - END IF; - - -- eql_v3 SEM index-term functions that must stay inlinable for - -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause - -- in the legacy combined pin_search_path.sql. - SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids - FROM pg_catalog.pg_proc p - JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) - AND ( - (p.pronargs = 2 - AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq', - 'ore_block_256_lt', 'ore_block_256_lte', - 'ore_block_256_gt', 'ore_block_256_gte')) - OR (p.pronargs = 2 - AND p.proname IN ('ore_cllw_eq', 'ore_cllw_neq', - 'ore_cllw_lt', 'ore_cllw_lte', - 'ore_cllw_gt', 'ore_cllw_gte')) - OR (p.pronargs = 1 - AND p.proname IN ('ore_cllw', 'has_ore_cllw') - AND p.proargtypes[0] = jsonb_oid) - -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a - -- domain over bytea (native comparison operators and btree opclass), - -- so there are no ope-specific comparison functions to keep inlinable. - OR (p.pronargs = 1 - AND p.proname = 'ope_cllw' - AND p.proargtypes[0] = jsonb_oid) - OR (p.pronargs = 1 - AND p.proname = 'hmac_256' - AND p.proargtypes[0] = jsonb_oid) - OR (p.pronargs = 1 - AND p.proname = 'bloom_filter' - AND p.proargtypes[0] = jsonb_oid) - ); - - FOR fn_oid IN - SELECT p.oid - FROM pg_catalog.pg_proc p - JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) - AND p.prokind IN ('f', 'w') - AND NOT EXISTS ( - SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c - WHERE c LIKE 'search_path=%' - ) - AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[]))) - -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE, - -- taking >=1 argument typed as a jsonb-backed DOMAIN in eql_v3. - AND NOT ( - p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l - WHERE l.lanname = 'sql') - AND p.provolatile = 'i' - AND EXISTS ( - SELECT 1 - FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) - JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - WHERE dt.typtype = 'd' - AND dt.typbasetype = jsonb_oid - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) - ) - ) - -- Comment-marker fallback for hand-written inline-critical extension - -- functions that take no domain argument. - AND NOT EXISTS ( - SELECT 1 FROM pg_catalog.pg_description d - WHERE d.objoid = p.oid - AND d.classoid = 'pg_catalog.pg_proc'::regclass - AND d.description LIKE 'eql-inline-critical%' - ) - LOOP - EXECUTE pg_catalog.format( - 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public', - fn_oid::regprocedure - ); - END LOOP; -END $$; diff --git a/packages/cli/src/sql/cipherstash-encrypt-v3.sql b/packages/cli/src/sql/cipherstash-encrypt-v3.sql index 08da1ff80..f3ecc01d6 100644 --- a/packages/cli/src/sql/cipherstash-encrypt-v3.sql +++ b/packages/cli/src/sql/cipherstash-encrypt-v3.sql @@ -1,10 +1,11 @@ --! @file v3/schema.sql --! @brief EQL v3 schema creation --! ---! Creates the eql_v3 and eql_v3_internal schemas. eql_v3 is the public API: ---! the self-contained encrypted-domain type families (eql_v3.integer, eql_v3.bigint, ---! and future scalar domains) — their jsonb-backed domains, index-term ---! extractors, aggregates, AND the operator-backing comparison wrappers +--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted +--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in +--! public so application tables survive EQL schema uninstall. eql_v3 is the +--! public API for index-term extractors, aggregates, AND the operator-backing +--! comparison wrappers --! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment --! helpers). The wrappers are public because they are the function-form --! equivalent of every supported operator: platforms without operator support @@ -146,35 +147,43 @@ END $$; --! --! @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. +--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller +--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` — +--! both reached exclusively from plpgsql and btree operator-class support +--! contexts, where SQL functions can NEVER be inlined and instead pay the +--! per-call SQL-function executor (measured 3.5x the per-call cost of the +--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql +--! caches its plan across calls. The non-array guard preserves the v3 +--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original +--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`), +--! so the divergence stays unreachable in practice; JSON null and empty +--! array still return NULL exactly as before. CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb) RETURNS bytea[] IMMUTABLE AS $$ - 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; +DECLARE + result bytea[]; +BEGIN + IF val IS NULL OR jsonb_typeof(val) != 'array' THEN + RETURN NULL; + END IF; + SELECT array_agg(decode(value::text, 'hex')::bytea) + INTO result + FROM jsonb_array_elements_text(val) AS value; + RETURN result; +END; +$$ LANGUAGE plpgsql; ---! @internal Mark this hand-written helper inline-critical so the post-install ---! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving ---! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed ---! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does ---! not recognise it; this marker is the documented manual opt-in. +--! @internal Keep the inline-critical marker so the post-install +--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a +--! plpgsql function forces per-call configuration switching — measurable on a +--! helper invoked per compared value in the ore_block_256 opclass hot path. +--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the +--! structural skip in tasks/pin_search_path_v3.sql does not recognise it; +--! this marker is the documented manual opt-in. COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS - 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; + 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; --! @file v3/sem/ore_block_256/types.sql --! @brief ORE block index-term types (eql_v3 SEM). @@ -215,14 +224,15 @@ CREATE TYPE eql_v3_internal.ore_block_256 AS ( --! @internal --! @param val jsonb Array of hex-encoded ORE block terms --! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null ---! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the ---! planner can fold this per-encrypted-value helper into the calling query. ---! This deliberately diverges from the v2 plpgsql equivalent (intentionally ---! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only ---! evaluates the array path for an array, so a non-array JSON scalar returns ---! NULL here instead of raising. The sole caller (`ore_block_256`) only reaches ---! this when `has_ore_block_256(val)` is true, which now requires `val->'ob'` ---! to be a JSON array, so the non-array branch is unreachable in practice. +--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller +--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached +--! from an inlinable context — as `LANGUAGE sql` it paid the per-call +--! SQL-function executor on every compared value in the opclass hot path +--! (measured: +43% on ORE ordered scans vs the plpgsql form). The +--! non-array guard preserves the v3 behaviour (returns NULL for a +--! non-array scalar; the v2 plpgsql original raised); the caller only +--! reaches this when `has_ore_block_256(val)` is true, which requires +--! `val->'ob'` to be a JSON array, so that branch stays unreachable. --! An empty array (`ob: []`, what encrypting the empty string `""` produces) --! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms. --! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and @@ -234,25 +244,33 @@ CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb) RETURNS eql_v3_internal.ore_block_256 IMMUTABLE AS $$ - SELECT CASE WHEN jsonb_typeof(val) = 'array' - THEN ROW(COALESCE( - ( - SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) - FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b - ), - ARRAY[]::eql_v3_internal.ore_block_256_term[] - ))::eql_v3_internal.ore_block_256 - ELSE NULL - END; -$$ LANGUAGE sql; +DECLARE + terms eql_v3_internal.ore_block_256_term[]; +BEGIN + IF val IS NULL OR jsonb_typeof(val) != 'array' THEN + RETURN NULL; + END IF; + SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) + INTO terms + FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b; + -- plpgsql pitfall: `SELECT INTO ` assigns the + -- select-list columns FIELD-WISE into the variable — return the row + -- constructor directly instead. The COALESCE stays load-bearing for the + -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and + -- the comparator needs an EMPTY terms array, not NULL terms. + RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256; +END; +$$ LANGUAGE plpgsql; ---! @internal Mark this hand-written helper inline-critical so the post-install ---! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving ---! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed ---! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does ---! not recognise it; this marker is the documented manual opt-in. +--! @internal Keep the inline-critical marker so the post-install +--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a +--! plpgsql function forces per-call configuration switching — measurable on a +--! helper invoked per compared value in the ore_block_256 opclass hot path. +--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the +--! structural skip in tasks/pin_search_path_v3.sql does not recognise it; +--! this marker is the documented manual opt-in. COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS - 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; + 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; --! @brief Extract ORE block index term from JSONB payload @@ -477,7 +495,7 @@ $$ LANGUAGE plpgsql; --! outright — no hand-written operators, comparator, or operator class (the --! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole --! comparison chain inlinable, so a functional btree index on ---! `eql_v3.ord_ope_term(col)` engages structurally for the `_ord_ope` +--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` --! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec --! CLLW-*ORE* composite compared by a custom per-byte protocol. --! @@ -508,28 +526,6 @@ CREATE DOMAIN eql_v3_internal.hmac_256 AS text; --! --! @note Self-contained: references no eql_v2 symbol. CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; - ---! @file v3/sem/ore_cllw/types.sql ---! @brief CLLW ORE index term type for STE-vec range queries (eql_v3 SEM) ---! ---! Composite type for CLLW (Copyless Logarithmic Width) Order-Revealing ---! Encryption. The ciphertext is stored in the `oc` field of encrypted data ---! payloads (Standard-mode `ste_vec` elements). Used by the range operators ---! (`<`, `<=`, `>`, `>=`) when an sv element carries an `oc` term. ---! ---! The wire-format `oc` value is a hex string with a leading domain-tag byte ---! (`0x00` numeric, `0x01` string) followed by the CLLW ciphertext. The ---! decoded `bytes` field carries the full byte string including the tag — the ---! comparator is variable-length capable, so numeric and string values within ---! the same column order correctly: the domain tag separates the ranges ---! (numeric < string) and the within-domain comparison falls through to the ---! CLLW per-byte protocol. ---! ---! @note This is a transient type used only during query execution. ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE TYPE eql_v3_internal.ore_cllw AS ( - bytes bytea -); -- AUTOMATICALLY GENERATED FILE. --! @file v3/scalars/timestamp/timestamp_types.sql @@ -537,12 +533,12 @@ CREATE TYPE eql_v3_internal.ore_cllw AS ( DO $$ BEGIN - --! @brief Encrypted domain eql_v3.timestamp. + --! @brief Encrypted domain public.eql_v3_timestamp. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'timestamp' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.timestamp AS jsonb + CREATE DOMAIN public.eql_v3_timestamp AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -552,12 +548,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.timestamp_eq. + COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)'; + + --! @brief Encrypted domain public.eql_v3_timestamp_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.timestamp_eq AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -568,12 +566,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.timestamp_ord_ore. + COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)'; + + --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.timestamp_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -586,30 +586,32 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.timestamp_ord. + COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_timestamp_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.timestamp_ord AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.timestamp_ord_ope. + COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.timestamp_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -619,6 +621,8 @@ BEGIN AND VALUE->>'v' = '3' ); END IF; + + COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; END $$; @@ -869,7 +873,7 @@ CREATE OPERATOR public.>= ( --! Inlinable single-statement SQL — the body is a strict expression of the --! argument (`->>` and `decode` are both STRICT), so the planner folds this --! into the calling query and functional btree indexes built on ---! `eql_v3.ord_ope_term(col)` (which calls this) engage structurally, the +--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the --! same way the hmac_256 equality chain does. --! --! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and @@ -888,6 +892,44 @@ $$; COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)'; + +--! @file v3/sem/hmac_256/functions.sql +--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). +--! +--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and +--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar +--! domains extract from the jsonb payload directly via a cast to the domain. +--! (Doc comments deliberately avoid naming eql_v2 symbols so the +--! self-containment grep stays clean.) + +--! @brief Extract HMAC-SHA256 index term from JSONB payload +--! +--! Inlinable single-statement SQL — the planner can fold this into the calling +--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` +--! (which calls this) engage structurally. +--! +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent +CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) + RETURNS eql_v3_internal.hmac_256 + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 +$$; + + +--! @brief Check if JSONB payload contains HMAC-SHA256 index term +--! +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True if 'hm' field is present and non-null +CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) + RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm') IS NOT NULL +$$; -- AUTOMATICALLY GENERATED FILE. --! @file v3/scalars/text/text_types.sql @@ -895,12 +937,12 @@ COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS DO $$ BEGIN - --! @brief Encrypted domain eql_v3.text. + --! @brief Encrypted domain public.eql_v3_text. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text AS jsonb + CREATE DOMAIN public.eql_v3_text AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -910,12 +952,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.text_eq. + COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)'; + + --! @brief Encrypted domain public.eql_v3_text_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_eq AS jsonb + CREATE DOMAIN public.eql_v3_text_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -926,12 +970,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.text_match. + COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)'; + + --! @brief Encrypted domain public.eql_v3_text_match. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_match' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_match AS jsonb + CREATE DOMAIN public.eql_v3_text_match AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -942,12 +988,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.text_ord_ore. + COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (containment)'; + + --! @brief Encrypted domain public.eql_v3_text_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -961,31 +1009,33 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.text_ord. + COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_text_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_ord AS jsonb + CREATE DOMAIN public.eql_v3_text_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.text_ord_ope. + COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_text_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -997,12 +1047,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.text_search. + COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_text_search_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_search' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_search AS jsonb + CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1016,45 +1068,29 @@ BEGIN AND VALUE->>'v' = '3' ); END IF; -END -$$; ---! @file v3/sem/hmac_256/functions.sql ---! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). ---! ---! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and ---! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar ---! domains extract from the jsonb payload directly via a cast to the domain. ---! (Doc comments deliberately avoid naming eql_v2 symbols so the ---! self-containment grep stays clean.) - ---! @brief Extract HMAC-SHA256 index term from JSONB payload ---! ---! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` ---! (which calls this) engage structurally. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent -CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) - RETURNS eql_v3_internal.hmac_256 - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 -$$; + COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, containment)'; + --! @brief Encrypted domain public.eql_v3_text_search. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_text_search AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND VALUE ? 'bf' + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Check if JSONB payload contains HMAC-SHA256 index term ---! ---! @param val jsonb containing encrypted EQL payload ---! @return boolean True if 'hm' field is present and non-null -CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) - RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm') IS NOT NULL + COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, containment)'; +END $$; --! @file v3/sem/bloom_filter/functions.sql @@ -1120,12 +1156,12 @@ $$; DO $$ BEGIN - --! @brief Encrypted domain eql_v3.smallint. + --! @brief Encrypted domain public.eql_v3_smallint. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'smallint' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.smallint AS jsonb + CREATE DOMAIN public.eql_v3_smallint AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1135,12 +1171,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.smallint_eq. + COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)'; + + --! @brief Encrypted domain public.eql_v3_smallint_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'smallint_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.smallint_eq AS jsonb + CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1151,12 +1189,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.smallint_ord_ore. + COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)'; + + --! @brief Encrypted domain public.eql_v3_smallint_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.smallint_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1169,30 +1209,32 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.smallint_ord. + COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_smallint_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'smallint_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.smallint_ord AS jsonb + CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.smallint_ord_ope. + COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_smallint_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.smallint_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1202,6 +1244,8 @@ BEGIN AND VALUE->>'v' = '3' ); END IF; + + COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. @@ -1211,12 +1255,12 @@ $$; DO $$ BEGIN - --! @brief Encrypted domain eql_v3.real. + --! @brief Encrypted domain public.eql_v3_real. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'real' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.real AS jsonb + CREATE DOMAIN public.eql_v3_real AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1226,12 +1270,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.real_eq. + COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)'; + + --! @brief Encrypted domain public.eql_v3_real_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'real_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.real_eq AS jsonb + CREATE DOMAIN public.eql_v3_real_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1242,12 +1288,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.real_ord_ore. + COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)'; + + --! @brief Encrypted domain public.eql_v3_real_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.real_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1260,30 +1308,32 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.real_ord. + COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_real_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'real_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.real_ord AS jsonb + CREATE DOMAIN public.eql_v3_real_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.real_ord_ope. + COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_real_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.real_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1293,6 +1343,8 @@ BEGIN AND VALUE->>'v' = '3' ); END IF; + + COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. @@ -1302,12 +1354,12 @@ $$; DO $$ BEGIN - --! @brief Encrypted domain eql_v3.numeric. + --! @brief Encrypted domain public.eql_v3_numeric. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'numeric' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.numeric AS jsonb + CREATE DOMAIN public.eql_v3_numeric AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1317,12 +1369,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.numeric_eq. + COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)'; + + --! @brief Encrypted domain public.eql_v3_numeric_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'numeric_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.numeric_eq AS jsonb + CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1333,12 +1387,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.numeric_ord_ore. + COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)'; + + --! @brief Encrypted domain public.eql_v3_numeric_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.numeric_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1351,30 +1407,32 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.numeric_ord. + COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_numeric_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'numeric_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.numeric_ord AS jsonb + CREATE DOMAIN public.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 ? 'op' AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.numeric_ord_ope. + COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_numeric_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.numeric_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1384,6 +1442,8 @@ BEGIN AND VALUE->>'v' = '3' ); END IF; + + COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. @@ -1393,12 +1453,12 @@ $$; DO $$ BEGIN - --! @brief Encrypted domain eql_v3.integer. + --! @brief Encrypted domain public.eql_v3_integer. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'integer' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.integer AS jsonb + CREATE DOMAIN public.eql_v3_integer AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1408,12 +1468,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.integer_eq. + COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)'; + + --! @brief Encrypted domain public.eql_v3_integer_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'integer_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.integer_eq AS jsonb + CREATE DOMAIN public.eql_v3_integer_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1424,12 +1486,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.integer_ord_ore. + COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)'; + + --! @brief Encrypted domain public.eql_v3_integer_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.integer_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1442,30 +1506,32 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.integer_ord. + COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_integer_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'integer_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.integer_ord AS jsonb + CREATE DOMAIN public.eql_v3_integer_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.integer_ord_ope. + COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_integer_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.integer_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1475,6 +1541,8 @@ BEGIN AND VALUE->>'v' = '3' ); END IF; + + COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. @@ -1484,12 +1552,12 @@ $$; DO $$ BEGIN - --! @brief Encrypted domain eql_v3.double. + --! @brief Encrypted domain public.eql_v3_double. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'double' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.double AS jsonb + CREATE DOMAIN public.eql_v3_double AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1499,12 +1567,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.double_eq. + COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)'; + + --! @brief Encrypted domain public.eql_v3_double_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'double_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.double_eq AS jsonb + CREATE DOMAIN public.eql_v3_double_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1515,12 +1585,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.double_ord_ore. + COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)'; + + --! @brief Encrypted domain public.eql_v3_double_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.double_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1533,30 +1605,32 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.double_ord. + COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_double_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'double_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.double_ord AS jsonb + CREATE DOMAIN public.eql_v3_double_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.double_ord_ope. + COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_double_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.double_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1566,6 +1640,8 @@ BEGIN AND VALUE->>'v' = '3' ); END IF; + + COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. @@ -1575,12 +1651,12 @@ $$; DO $$ BEGIN - --! @brief Encrypted domain eql_v3.date. + --! @brief Encrypted domain public.eql_v3_date. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'date' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.date AS jsonb + CREATE DOMAIN public.eql_v3_date AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1590,12 +1666,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.date_eq. + COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)'; + + --! @brief Encrypted domain public.eql_v3_date_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'date_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.date_eq AS jsonb + CREATE DOMAIN public.eql_v3_date_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1606,12 +1684,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.date_ord_ore. + COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)'; + + --! @brief Encrypted domain public.eql_v3_date_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.date_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1624,30 +1704,32 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.date_ord. + COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_date_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'date_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.date_ord AS jsonb + CREATE DOMAIN public.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 ? 'op' AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.date_ord_ope. + COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_date_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.date_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1657,6 +1739,8 @@ BEGIN AND VALUE->>'v' = '3' ); END IF; + + COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. @@ -1666,12 +1750,12 @@ $$; DO $$ BEGIN - --! @brief Encrypted domain eql_v3.bigint. + --! @brief Encrypted domain public.eql_v3_bigint. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'bigint' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.bigint AS jsonb + CREATE DOMAIN public.eql_v3_bigint AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1681,12 +1765,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.bigint_eq. + COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)'; + + --! @brief Encrypted domain public.eql_v3_bigint_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'bigint_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.bigint_eq AS jsonb + CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1697,12 +1783,14 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.bigint_ord_ore. + COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)'; + + --! @brief Encrypted domain public.eql_v3_bigint_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.bigint_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1715,30 +1803,32 @@ BEGIN ); END IF; - --! @brief Encrypted domain eql_v3.bigint_ord. + COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_bigint_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'bigint_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.bigint_ord AS jsonb + CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.bigint_ord_ope. + COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_bigint_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.bigint_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1748,27564 +1838,34165 @@ BEGIN AND VALUE->>'v' = '3' ); END IF; + + COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; END $$; +-- AUTOMATICALLY GENERATED FILE. ---! @file v3/sem/ore_cllw/functions.sql ---! @brief CLLW ORE index-term extraction and comparison (eql_v3 SEM). +--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_timestamp_ord_ore. ---! @brief Extract CLLW ORE index term from raw jsonb ---! ---! Returns the CLLW ORE ciphertext from the `oc` field of a single sv element ---! supplied as raw jsonb. Inlinable single-statement SQL — the planner folds ---! the body into the calling query. ---! ---! **Missing-`oc` semantics**: returns SQL-level NULL (not a composite with ---! NULL bytes) when `oc` is absent, so btree's NULL handling filters those ---! rows from range queries. ---! ---! @param val jsonb An object carrying an `oc` field ---! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL ---! when the `oc` field is absent. ---! @see eql_v3_internal.has_ore_cllw ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw(val jsonb) - RETURNS eql_v3_internal.ore_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN val ->> 'oc' IS NULL THEN NULL - ELSE ROW(decode(val ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw - END -$$; +--! @brief Index extractor for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -COMMENT ON FUNCTION eql_v3_internal.ore_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW extractor; must stay inlinable (unpinned search_path)'; +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Check if a raw jsonb value contains a CLLW ORE index term ---! @param val jsonb An object that may carry an `oc` field ---! @return boolean True if `oc` field is present and non-null -CREATE FUNCTION eql_v3_internal.has_ore_cllw(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT val ->> 'oc' IS NOT NULL -$$; +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -COMMENT ON FUNCTION eql_v3_internal.has_ore_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW presence helper; must stay inlinable (unpinned search_path)'; +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief CLLW per-byte comparison helper ---! @internal ---! ---! Byte-by-byte comparison implementing the CLLW order-revealing protocol. ---! Identify the index of the first differing byte; if `(y_byte + 1) == x_byte` ---! (mod 256) there, then x > y; otherwise x < y. Equal inputs return 0. Inputs ---! MUST be the same length (the caller guarantees this). Stays `LANGUAGE ---! plpgsql` — the per-byte loop can't be a single inlinable SQL expression. ---! ---! @param a bytea First CLLW ciphertext slice ---! @param b bytea Second CLLW ciphertext slice ---! @return integer -1, 0, or 1 ---! @throws Exception if inputs are different lengths ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term_bytes(a bytea, b bytea) -RETURNS int - SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - len_a INT; - len_b INT; - i INT; - first_diff INT := 0; -BEGIN +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; - len_a := LENGTH(a); - len_b := LENGTH(b); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; - IF len_a != len_b THEN - RAISE EXCEPTION 'ore_cllw index terms are not the same length'; - END IF; +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$; - FOR i IN 1..len_a LOOP - IF first_diff = 0 AND get_byte(a, i - 1) != get_byte(b, i - 1) THEN - first_diff := i; - END IF; - END LOOP; +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; - IF first_diff = 0 THEN - RETURN 0; - END IF; +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; - IF ((get_byte(b, first_diff - 1) + 1) & 255) = get_byte(a, first_diff - 1) THEN - RETURN 1; - ELSE - RETURN -1; - END IF; -END; -$$ LANGUAGE plpgsql; +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Variable-length CLLW ORE term comparison ---! @internal ---! ---! Three-way comparison of two CLLW ORE ciphertext terms of potentially ---! different lengths. Compares the shared prefix via the CLLW per-byte ---! protocol; on equal prefixes, the shorter input sorts first. The leading ---! domain-tag byte makes numeric (`0x00`) sort before string (`0x01`). Stays ---! `LANGUAGE plpgsql` because it dispatches to `compare_ore_cllw_term_bytes`. ---! ---! btree filters NULL composites at the row level, so this should never see a ---! NULL composite under normal operation; the IS-NULL guard returns NULL ---! defensively. A non-NULL composite with NULL `bytes` is a contract violation ---! — the extractor returns SQL NULL (not ROW(NULL)) on missing `oc`, so raise ---! loudly rather than silently misorder. ---! ---! @param a eql_v3_internal.ore_cllw First term ---! @param b eql_v3_internal.ore_cllw Second term ---! @return integer -1, 0, or 1; NULL if either composite is NULL ---! @throws Exception if either composite has a NULL `bytes` field ---! @see eql_v3_internal.compare_ore_cllw_term_bytes -CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) -RETURNS int - SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - len_a INT; - len_b INT; - common_len INT; - cmp_result INT; -BEGIN - -- The `::text` cast is load-bearing, not a stylistic choice. For the - -- single-field `ore_cllw` composite, `ROW(NULL)::ore_cllw IS NULL` is TRUE - -- but `(ROW(NULL)::ore_cllw)::text IS NULL` is FALSE. Casting to text first - -- means a NULL-component composite falls THROUGH to the RAISE below (the - -- extractor-invariant violation) instead of silently returning NULL and - -- masking it. A plain `a IS NULL` would reintroduce that masking bug. - IF a::text IS NULL OR b::text IS NULL THEN - RETURN NULL; - END IF; - - IF a.bytes IS NULL OR b.bytes IS NULL THEN - RAISE EXCEPTION 'eql_v3_internal.compare_ore_cllw_term: composite has NULL bytes field — extractor invariant violated. Check that the index expression uses eql_v3_internal.ore_cllw(...) and not a hand-crafted ROW(NULL).'; - END IF; - - len_a := LENGTH(a.bytes); - len_b := LENGTH(b.bytes); - - IF len_a = 0 AND len_b = 0 THEN - RETURN 0; - ELSIF len_a = 0 THEN - RETURN -1; - ELSIF len_b = 0 THEN - RETURN 1; - END IF; - - IF len_a < len_b THEN - common_len := len_a; - ELSE - common_len := len_b; - END IF; - - cmp_result := eql_v3_internal.compare_ore_cllw_term_bytes( - SUBSTRING(a.bytes FROM 1 FOR common_len), - SUBSTRING(b.bytes FROM 1 FOR common_len) - ); - - IF cmp_result = -1 THEN - RETURN -1; - ELSIF cmp_result = 1 THEN - RETURN 1; - END IF; - - IF len_a < len_b THEN - RETURN -1; - ELSIF len_a > len_b THEN - RETURN 1; - ELSE - RETURN 0; - END IF; -END; -$$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql ---! @brief Functions for eql_v3.timestamp_ord_ore. - ---! @brief Index extractor for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param selector text ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector text) -RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text) +RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param selector integer ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector integer) -RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer) +RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. --! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ore) -RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +--! @param selector public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore) +RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. --! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ore +--! @param selector public.eql_v3_timestamp_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql ---! @brief Functions for eql_v3.timestamp_ord_ope. +--! @brief Functions for public.eql_v3_timestamp_ord_ope. ---! @brief Index extractor for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Index extractor for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector text ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector text) -RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text) +RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector integer ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector integer) -RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer) +RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ope) -RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +--! @param selector public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope) +RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ope +--! @param selector public.eql_v3_timestamp_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/timestamp/timestamp_ord_functions.sql ---! @brief Functions for eql_v3.timestamp_ord. +--! @brief Functions for public.eql_v3_timestamp_ord. ---! @brief Index extractor for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param selector text ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector text) -RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text) +RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param selector integer ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector integer) -RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer) +RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param selector eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord) -RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +--! @param selector public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord) +RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param selector eql_v3.timestamp_ord +--! @param selector public.eql_v3_timestamp_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.eql_v3_timestamp_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_functions.sql ---! @brief Functions for eql_v3.text_search. +--! @file v3/scalars/timestamp/query_timestamp_types.sql +--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql +--! @brief Functions for public.eql_v3_timestamp_eq. ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Index extractor for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_search) +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_search) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.text_search) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_search) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = 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 +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_search) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> 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 +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a 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) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a 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) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.eql_v3_timestamp_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a 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) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a 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) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.eql_v3_timestamp_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a 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) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a 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) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.eql_v3_timestamp_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a 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) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a 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) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.eql_v3_timestamp_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::eql_v3.text_search) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) @> eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::eql_v3.text_search) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) <@ eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector text ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector text) -RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +--! @return public.eql_v3_timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text) +RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector integer ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector integer) -RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +--! @return public.eql_v3_timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer) +RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param selector eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_search) -RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +--! @param selector public.eql_v3_timestamp_eq +--! @return public.eql_v3_timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq) +RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param selector eql_v3.text_search +--! @param selector public.eql_v3_timestamp_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_search) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_search, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_search, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_search, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.eql_v3_timestamp_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ore_functions.sql ---! @brief Functions for eql_v3.text_ord_ore. +--! @file encrypted_domain/text/text_search_ore_functions.sql +--! @brief Functions for public.eql_v3_text_search_ore. ---! @brief Index extractor for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Index extractor for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Index extractor for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore) RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore +--! @brief Index extractor for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param b eql_v3.text_ord_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param b eql_v3.text_ord_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param b eql_v3.text_ord_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param b eql_v3.text_ord_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param b eql_v3.text_ord_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param b eql_v3.text_ord_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param b eql_v3.text_ord_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param b eql_v3.text_ord_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) <@ eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param selector text ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector text) -RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text) +RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param selector integer ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector integer) -RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer) +RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param selector eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +--! @param selector public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore) +RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param selector eql_v3.text_ord_ore +--! @param selector public.eql_v3_text_search_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_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 +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. --! @param a jsonb ---! @param b eql_v3.text_ord_ore +--! @param b public.eql_v3_text_search_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ope_functions.sql ---! @brief Functions for eql_v3.text_ord_ope. +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for public.eql_v3_text_search. ---! @brief Index extractor for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Index extractor for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Index extractor for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope +--! @brief Index extractor for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_search. --! @param a jsonb ---! @param b eql_v3.text_ord_ope +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_search. --! @param a jsonb ---! @param b eql_v3.text_ord_ope +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_search. --! @param a jsonb ---! @param b eql_v3.text_ord_ope +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_search. --! @param a jsonb ---! @param b eql_v3.text_ord_ope +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_search. --! @param a jsonb ---! @param b eql_v3.text_ord_ope +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_search. --! @param a jsonb ---! @param b eql_v3.text_ord_ope +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_search. --! @param a jsonb ---! @param b eql_v3.text_ord_ope +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_search. --! @param a jsonb ---! @param b eql_v3.text_ord_ope +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) <@ eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param selector text ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector text) -RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text) +RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param selector integer ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector integer) -RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer) +RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_text_search. --! @param a jsonb ---! @param selector eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ope) -RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +--! @param selector public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search) +RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_text_search. --! @param a jsonb ---! @param selector eql_v3.text_ord_ope +--! @param selector public.eql_v3_text_search --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_text_search. --! @param a jsonb ---! @param b eql_v3.text_ord_ope +--! @param b public.eql_v3_text_search --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_functions.sql ---! @brief Functions for eql_v3.text_ord. +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_text_ord_ore. ---! @brief Index extractor for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Index extractor for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord) +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Index extractor for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord) +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore) RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param selector text ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector text) -RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text) +RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param selector integer ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector integer) -RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer) +RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param selector eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord) -RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +--! @param selector public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore) +RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param selector eql_v3.text_ord +--! @param selector public.eql_v3_text_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.eql_v3_text_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql ---! @brief Functions for eql_v3.smallint_ord_ore. +--! @file encrypted_domain/text/text_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_text_ord_ope. ---! @brief Index extractor for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.smallint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ore +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ore +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ore +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ore +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ore +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ore +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ore +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ore +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param selector text ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector text) -RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text) +RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param selector integer ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector integer) -RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer) +RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param selector eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ore) -RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +--! @param selector public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope) +RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param selector eql_v3.smallint_ord_ore +--! @param selector public.eql_v3_text_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ore +--! @param b public.eql_v3_text_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql ---! @brief Functions for eql_v3.smallint_ord_ope. +--! @file encrypted_domain/text/text_ord_functions.sql +--! @brief Functions for public.eql_v3_text_ord. ---! @brief Index extractor for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Index extractor for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ope +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ope +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ope +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ope +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ope +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ope +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ope +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ope +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector text ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector text) -RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text) +RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector integer ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector integer) -RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer) +RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param selector eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ope) -RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +--! @param selector public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord) +RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param selector eql_v3.smallint_ord_ope +--! @param selector public.eql_v3_text_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param b eql_v3.smallint_ord_ope +--! @param b public.eql_v3_text_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_functions.sql ---! @brief Functions for eql_v3.smallint_ord. +--! @file v3/scalars/text/query_text_types.sql +--! @brief Query-operand domains for text (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Index extractor for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.smallint_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)'; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_match AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) = eql_v3.ord_term(b) $$; + COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (containment)'; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)'; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <> eql_v3.ord_term(b) $$; + --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, containment)'; + + --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_search AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, containment)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_functions.sql +--! @brief Functions for public.eql_v3_text_match. ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord +--! @brief Index extractor for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b eql_v3.smallint_ord +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b eql_v3.smallint_ord +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b eql_v3.smallint_ord +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b eql_v3.smallint_ord +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b eql_v3.smallint_ord +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b eql_v3.smallint_ord +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a jsonb +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_match) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a jsonb +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector text ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector text) -RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +--! @return public.eql_v3_text_match +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text) +RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector integer ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector integer) -RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +--! @return public.eql_v3_text_match +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer) +RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param selector eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord) -RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +--! @param selector public.eql_v3_text_match +--! @return public.eql_v3_text_match +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match) +RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param selector eql_v3.smallint_ord +--! @param selector public.eql_v3_text_match --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b eql_v3.smallint_ord +--! @param b public.eql_v3_text_match --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ore_functions.sql ---! @brief Functions for eql_v3.real_ord_ore. +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for public.eql_v3_text_eq. ---! @brief Index extractor for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.real_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_eq. --! @param a jsonb ---! @param b eql_v3.real_ord_ore +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_eq. --! @param a jsonb ---! @param b eql_v3.real_ord_ore +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b eql_v3.real_ord_ore +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b eql_v3.real_ord_ore +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b eql_v3.real_ord_ore +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b eql_v3.real_ord_ore +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b eql_v3.real_ord_ore +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b eql_v3.real_ord_ore +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector text ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector text) -RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +--! @return public.eql_v3_text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text) +RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector integer ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector integer) -RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +--! @return public.eql_v3_text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer) +RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param selector eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ore) -RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +--! @param selector public.eql_v3_text_eq +--! @return public.eql_v3_text_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq) +RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param selector eql_v3.real_ord_ore +--! @param selector public.eql_v3_text_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b eql_v3.real_ord_ore +--! @param b public.eql_v3_text_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ope_functions.sql ---! @brief Functions for eql_v3.real_ord_ope. +--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_smallint_ord_ore. ---! @brief Index extractor for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.real_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param b eql_v3.real_ord_ope +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param b eql_v3.real_ord_ope +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param b eql_v3.real_ord_ope +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param b eql_v3.real_ord_ope +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param b eql_v3.real_ord_ope +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param b eql_v3.real_ord_ope +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param b eql_v3.real_ord_ope +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param b eql_v3.real_ord_ope +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param selector text ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector text) -RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +--! @return public.eql_v3_smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector text) +RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param selector integer ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector integer) -RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +--! @return public.eql_v3_smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector integer) +RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param selector eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ope) -RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +--! @param selector public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ore) +RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param selector eql_v3.real_ord_ope +--! @param selector public.eql_v3_smallint_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. --! @param a jsonb ---! @param b eql_v3.real_ord_ope +--! @param b public.eql_v3_smallint_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_functions.sql ---! @brief Functions for eql_v3.real_ord. +--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_smallint_ord_ope. ---! @brief Index extractor for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.real_ord) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.real_ord. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param b eql_v3.real_ord +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.real_ord. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param b eql_v3.real_ord +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.real_ord. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param b eql_v3.real_ord +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.real_ord. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param b eql_v3.real_ord +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.real_ord. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param b eql_v3.real_ord +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.real_ord. +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param b eql_v3.real_ord +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b eql_v3.real_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param b eql_v3.real_ord +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b eql_v3.real_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param b eql_v3.real_ord +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param selector text ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector text) -RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +--! @return public.eql_v3_smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector text) +RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param selector integer ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector integer) -RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +--! @return public.eql_v3_smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector integer) +RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param selector eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord) -RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +--! @param selector public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ope) +RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param selector eql_v3.real_ord +--! @param selector public.eql_v3_smallint_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b eql_v3.real_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. --! @param a jsonb ---! @param b eql_v3.real_ord +--! @param b public.eql_v3_smallint_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql ---! @brief Functions for eql_v3.numeric_ord_ore. +--! @file encrypted_domain/smallint/smallint_ord_functions.sql +--! @brief Functions for public.eql_v3_smallint_ord. ---! @brief Index extractor for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = 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 +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> 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 +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < 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 +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= 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 +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > 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 +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= 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 +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param selector text ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector text) -RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +--! @return public.eql_v3_smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector text) +RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param selector integer ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector integer) -RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +--! @return public.eql_v3_smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector integer) +RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param selector eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ore) -RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +--! @param selector public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord) +RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param selector eql_v3.numeric_ord_ore +--! @param selector public.eql_v3_smallint_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.eql_v3_smallint_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql ---! @brief Functions for eql_v3.numeric_ord_ope. +--! @file v3/scalars/smallint/query_smallint_types.sql +--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Index extractor for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.numeric_ord_ope) -RETURNS eql_v3_internal.ope_cllw +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_functions.sql +--! @brief Functions for public.eql_v3_smallint_eq. + +--! @brief Index extractor for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @brief Operator wrapper for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ope +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @brief Operator wrapper for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ope +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ope +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) < eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ope +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <= eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ope +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) > eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ope +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) >= eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ope +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ope +--! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param selector text ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector text) -RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +--! @return public.eql_v3_smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text) +RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param selector integer ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector integer) -RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +--! @return public.eql_v3_smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer) +RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param selector eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ope) -RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +--! @param selector public.eql_v3_smallint_eq +--! @return public.eql_v3_smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq) +RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param selector eql_v3.numeric_ord_ope +--! @param selector public.eql_v3_smallint_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ope +--! @param b public.eql_v3_smallint_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_functions.sql ---! @brief Functions for eql_v3.numeric_ord. +--! @file encrypted_domain/real/real_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_real_ord_ore. ---! @brief Index extractor for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Index extractor for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore) RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.numeric_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.numeric_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.numeric_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.numeric_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param selector text ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector text) -RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text) +RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param selector integer ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector integer) -RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer) +RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param selector eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord) -RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +--! @param selector public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore) +RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param selector eql_v3.numeric_ord +--! @param selector public.eql_v3_real_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. --! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @param b public.eql_v3_real_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ore_functions.sql ---! @brief Functions for eql_v3.integer_ord_ore. +--! @file encrypted_domain/real/real_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_real_ord_ope. ---! @brief Index extractor for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.integer_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b eql_v3.integer_ord_ore +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b eql_v3.integer_ord_ore +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b eql_v3.integer_ord_ore +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b eql_v3.integer_ord_ore +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b eql_v3.integer_ord_ore +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b eql_v3.integer_ord_ore +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b eql_v3.integer_ord_ore +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b eql_v3.integer_ord_ore +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector text ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector text) -RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text) +RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector integer ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector integer) -RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer) +RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param selector eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ore) -RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +--! @param selector public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope) +RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param selector eql_v3.integer_ord_ore +--! @param selector public.eql_v3_real_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b eql_v3.integer_ord_ore +--! @param b public.eql_v3_real_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ope_functions.sql ---! @brief Functions for eql_v3.integer_ord_ope. +--! @file encrypted_domain/real/real_ord_functions.sql +--! @brief Functions for public.eql_v3_real_ord. ---! @brief Index extractor for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Index extractor for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b eql_v3.integer_ord_ope +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b eql_v3.integer_ord_ope +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b eql_v3.integer_ord_ope +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b eql_v3.integer_ord_ope +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b eql_v3.integer_ord_ope +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b eql_v3.integer_ord_ope +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param b eql_v3.integer_ord_ope +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param b eql_v3.integer_ord_ope +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector text ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector text) -RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text) +RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector integer ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector integer) -RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer) +RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param selector eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ope) -RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +--! @param selector public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord) +RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param selector eql_v3.integer_ord_ope +--! @param selector public.eql_v3_real_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param b eql_v3.integer_ord_ope +--! @param b public.eql_v3_real_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_functions.sql ---! @brief Functions for eql_v3.integer_ord. - ---! @brief Index extractor for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.integer_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +--! @file v3/scalars/real/query_real_types.sql +--! @brief Query-operand domains for real (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.integer_ord) $$; + COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)'; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) = eql_v3.ord_term(b) $$; + --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)'; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.integer_ord) $$; + --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <> eql_v3.ord_term(b) $$; + COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)'; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord + --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_functions.sql +--! @brief Functions for public.eql_v3_real_eq. + +--! @brief Index extractor for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.integer_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$; ---! @brief Operator wrapper for eql_v3.integer_ord. +--! @brief Operator wrapper for public.eql_v3_real_eq. --! @param a jsonb ---! @param b eql_v3.integer_ord +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.integer_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$; ---! @brief Operator wrapper for eql_v3.integer_ord. +--! @brief Operator wrapper for public.eql_v3_real_eq. --! @param a jsonb ---! @param b eql_v3.integer_ord +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.integer_ord) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b eql_v3.integer_ord +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.integer_ord) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b eql_v3.integer_ord +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a jsonb +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a jsonb +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b eql_v3.integer_ord +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b eql_v3.integer_ord +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector text ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector text) -RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +--! @return public.eql_v3_real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text) +RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector integer ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector integer) -RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +--! @return public.eql_v3_real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer) +RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param selector eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord) -RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +--! @param selector public.eql_v3_real_eq +--! @return public.eql_v3_real_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq) +RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param selector eql_v3.integer_ord +--! @param selector public.eql_v3_real_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b eql_v3.integer_ord +--! @param b public.eql_v3_real_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ore_functions.sql ---! @brief Functions for eql_v3.double_ord_ore. +--! @file v3/scalars/numeric/query_numeric_types.sql +--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_numeric_ord_ore. ---! @brief Index extractor for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Index extractor for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore) RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.double_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.double_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.double_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.double_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.double_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.double_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.double_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.double_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector text ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector text) -RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text) +RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector integer ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector integer) -RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer) +RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param selector eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ore) -RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +--! @param selector public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore) +RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param selector eql_v3.double_ord_ore +--! @param selector public.eql_v3_numeric_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.double_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ope_functions.sql ---! @brief Functions for eql_v3.double_ord_ope. +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for public.eql_v3_numeric_ord. ---! @brief Index extractor for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Index extractor for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b eql_v3.double_ord_ope +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b eql_v3.double_ord_ope +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b eql_v3.double_ord_ope +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b eql_v3.double_ord_ope +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b eql_v3.double_ord_ope +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b eql_v3.double_ord_ope +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b eql_v3.double_ord_ope +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b eql_v3.double_ord_ope +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector text ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector text) -RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text) +RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector integer ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector integer) -RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer) +RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param selector eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ope) -RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +--! @param selector public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord) +RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param selector eql_v3.double_ord_ope +--! @param selector public.eql_v3_numeric_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b eql_v3.double_ord_ope +--! @param b public.eql_v3_numeric_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_functions.sql ---! @brief Functions for eql_v3.double_ord. +--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_numeric_ord_ope. ---! @brief Index extractor for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.double_ord) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.double_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.double_ord +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.double_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.double_ord +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.double_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.double_ord +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.double_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.double_ord +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.double_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.double_ord +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.double_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.double_ord +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b eql_v3.double_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.double_ord +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b eql_v3.double_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.double_ord +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector text ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector text) -RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text) +RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector integer ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector integer) -RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer) +RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param selector eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord) -RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +--! @param selector public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope) +RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param selector eql_v3.double_ord +--! @param selector public.eql_v3_numeric_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b eql_v3.double_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.double_ord +--! @param b public.eql_v3_numeric_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_ore_functions.sql ---! @brief Functions for eql_v3.date_ord_ore. +--! @file encrypted_domain/numeric/numeric_eq_functions.sql +--! @brief Functions for public.eql_v3_numeric_eq. ---! @brief Index extractor for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.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) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @param b public.eql_v3_numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.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) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @param b public.eql_v3_numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.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) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @param b public.eql_v3_numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.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) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; 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 +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param selector text ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector text) -RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +--! @return public.eql_v3_numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector text) +RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param selector integer ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector integer) -RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +--! @return public.eql_v3_numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector integer) +RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param selector eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ore) -RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +--! @param selector public.eql_v3_numeric_eq +--! @return public.eql_v3_numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_eq) +RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param selector eql_v3.date_ord_ore +--! @param selector public.eql_v3_numeric_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; 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 +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @param b public.eql_v3_numeric_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_ope_functions.sql ---! @brief Functions for eql_v3.date_ord_ope. - ---! @brief Index extractor for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.date_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +--! @file v3/scalars/integer/query_integer_types.sql +--! @brief Query-operand domains for integer (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)'; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) = eql_v3.ord_ope_term(b) $$; + --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)'; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_integer_ord_ore. + +--! @brief Index extractor for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.date_ord_ope +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.date_ord_ope +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) < eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.date_ord_ope +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.date_ord_ope +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) > eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.date_ord_ope +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) >= eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.date_ord_ope +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.date_ord_ope +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector text ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector text) -RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text) +RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector integer ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector integer) -RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer) +RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param selector eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ope) -RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +--! @param selector public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore) +RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param selector eql_v3.date_ord_ope +--! @param selector public.eql_v3_integer_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.date_ord_ope +--! @param b public.eql_v3_integer_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_functions.sql ---! @brief Functions for eql_v3.date_ord. +--! @file encrypted_domain/integer/integer_ord_functions.sql +--! @brief Functions for public.eql_v3_integer_ord. ---! @brief Index extractor for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for eql_v3.date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b eql_v3.date_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for eql_v3.date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b eql_v3.date_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for eql_v3.date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b eql_v3.date_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for eql_v3.date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b eql_v3.date_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for eql_v3.date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b eql_v3.date_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for eql_v3.date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b eql_v3.date_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b eql_v3.date_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_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 +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b eql_v3.date_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector text ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector text) -RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text) +RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector integer ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector integer) -RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer) +RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param selector eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord) -RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +--! @param selector public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord) +RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param selector eql_v3.date_ord +--! @param selector public.eql_v3_integer_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_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 +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b eql_v3.date_ord +--! @param b public.eql_v3_integer_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/boolean/boolean_types.sql ---! @brief Encrypted-domain types for boolean. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.boolean. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'boolean' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.boolean AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql ---! @brief Functions for eql_v3.bigint_ord_ore. +--! @file encrypted_domain/integer/integer_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_integer_ord_ope. ---! @brief Index extractor for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.bigint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector text ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector text) -RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text) +RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector integer ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector integer) -RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer) +RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param selector eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ore) -RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +--! @param selector public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope) +RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param selector eql_v3.bigint_ord_ore +--! @param selector public.eql_v3_integer_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql ---! @brief Functions for eql_v3.bigint_ord_ope. +--! @file encrypted_domain/integer/integer_eq_functions.sql +--! @brief Functions for public.eql_v3_integer_eq. ---! @brief Index extractor for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.bigint_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ope +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) = eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ope +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <> eql_v3.ord_ope_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ope +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) < eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ope +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <= eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ope +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) > eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ope +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) >= eql_v3.ord_ope_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ope +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ope +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param selector text ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector text) -RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +--! @return public.eql_v3_integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text) +RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param selector integer ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector integer) -RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +--! @return public.eql_v3_integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer) +RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param selector eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ope) -RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +--! @param selector public.eql_v3_integer_eq +--! @return public.eql_v3_integer_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq) +RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param selector eql_v3.bigint_ord_ope +--! @param selector public.eql_v3_integer_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b eql_v3.bigint_ord_ope +--! @param b public.eql_v3_integer_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_functions.sql ---! @brief Functions for eql_v3.bigint_ord. +--! @file v3/scalars/double/query_double_types.sql +--! @brief Query-operand domains for double (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_double_ord_ore. ---! @brief Index extractor for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Index extractor for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore) RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.bigint_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param b eql_v3.bigint_ord +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.bigint_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param b eql_v3.bigint_ord +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.bigint_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param b eql_v3.bigint_ord +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.bigint_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param b eql_v3.bigint_ord +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.bigint_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param b eql_v3.bigint_ord +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.bigint_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.bigint_ord. +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param b eql_v3.bigint_ord +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param b eql_v3.bigint_ord +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param b eql_v3.bigint_ord +--! @param b public.eql_v3_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param selector text ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector text) -RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text) +RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param selector integer ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector integer) -RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer) +RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param selector eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord) -RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +--! @param selector public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore) +RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param selector eql_v3.bigint_ord +--! @param selector public.eql_v3_double_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. --! @param a jsonb ---! @param b eql_v3.bigint_ord +--! @param b public.eql_v3_double_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. ---! @file v3/jsonb/types.sql ---! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! Three jsonb-backed domains (none over another domain — operators resolve ---! against the ultimate base type jsonb, so the native-jsonb firewall in ---! blockers.sql can attach): ---! - eql_v3.json — storage/root: an EQL envelope object ({i, v, ...}). ---! - eql_v3.jsonb_entry — a single sv element (returned by `->`). ---! - eql_v3.jsonb_query — a containment needle (sv elements, no ciphertext). +--! @file encrypted_domain/double/double_ord_functions.sql +--! @brief Functions for public.eql_v3_double_ord. ---! @brief Validate a single SteVec entry payload. ---! @internal ---! @param val jsonb Candidate entry payload. ---! @return boolean True when `val` is an sv entry with string `s`, string `c`, ---! and exactly one string deterministic term (`hm` XOR `oc`). -CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_entry_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 's') = 'string' - AND jsonb_typeof(val -> 'c') = 'string' - AND ( - (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'oc')) - OR - (jsonb_typeof(val -> 'oc') = 'string' AND NOT (val ? 'hm')) - ), - false - ) -$$; +--! @brief Index extractor for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Validate a SteVec containment query payload. ---! @internal ---! @param val jsonb Candidate query payload. ---! @return boolean True when `val` is `{"sv":[...]}` and every element carries ---! string `s`, no ciphertext, and exactly one string term (`hm` XOR ---! `oc`). -CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_query_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT COALESCE(( - jsonb_typeof(elem) = 'object' - AND jsonb_typeof(elem -> 's') = 'string' - AND NOT (elem ? 'c') - AND ( - (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'oc')) - OR - (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) - ) - ), false) - ), - false - ) -$$; - ---! @brief Validate a root SteVec document payload. ---! @internal ---! @param val jsonb Candidate document payload. ---! @return boolean True when `val` is an encrypted document envelope with ---! `v = 3`, `i`, an `sv` array, and valid sv entry elements. -CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_document_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND val ? 'v' - AND val ->> 'v' = '3' - AND val ? 'i' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT eql_v3_internal.is_valid_ste_vec_entry_payload(elem) - ), - false - ) -$$; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Storage/root domain for an encrypted JSONB column. ---! ---! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index ---! metadata). Root `c` is intentionally NOT required — an sv-array root payload ---! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` ---! array, so the domain accepts only SteVec **document** payloads and rejects ---! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is ---! what keeps `eql_v3.json` a typed document domain rather than a generic ---! encrypted envelope. The firewall in blockers.sql attaches to this domain to ---! stop native jsonb operators from reaching a column value. ---! ---! @note Constructing from inline JSON uses the standard DOMAIN cast: ---! `'{"i":{},"v":3,"sv":[...]}'::eql_v3.json`. -CREATE DOMAIN eql_v3.json AS jsonb - CHECK ( - eql_v3_internal.is_valid_ste_vec_document_payload(VALUE) - ); +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$; ---! @brief Domain type for an individual sv element. ---! ---! A single element inside an `sv` array: a JSON object that carries a selector ---! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for ---! hash-equality) or `oc` (CLLW ORE, for ordered queries) — they are mutually ---! exclusive. This is the type returned by `->` and accepted by the per-entry ---! extractors `eql_v3.eq_term` / `eql_v3.ore_cllw`. Extra fields (`a`, root ---! `i`/`v` merged in by `->`) are allowed. ---! ---! @see src/v3/jsonb/operators.sql -CREATE DOMAIN eql_v3.jsonb_entry AS jsonb - CHECK ( - eql_v3_internal.is_valid_ste_vec_entry_payload(VALUE) - ); +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$; ---! @brief Domain type for an STE-vec containment needle. ---! ---! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index ---! term but **never** a ciphertext (`c`). Each element must carry `s` and ---! exactly one deterministic term (`hm` XOR `oc`). Typing the needle this way ---! stops selector-only needles from casting and matching every row via bare ---! `jsonb @>`. ---! ---! @note Construct from inline JSON via the DOMAIN cast: ---! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.jsonb_query`. ---! @see eql_v3.to_ste_vec_query -CREATE DOMAIN eql_v3.jsonb_query AS jsonb - CHECK ( - eql_v3_internal.is_valid_ste_vec_query_payload(VALUE) - ); +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Convert an eql_v3.json to a jsonb_query needle. ---! ---! Normalises each sv element down to the matching-relevant fields: `s` plus ---! exactly one of `hm` / `oc`. Other fields (`c`, `a`, `i`/`v`, anything else) ---! are stripped. This is the canonical needle shape for `@>` containment. ---! Designed for use as a functional GIN index expression: ---! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. ---! ---! @param e eql_v3.json Source encrypted payload ---! @return eql_v3.jsonb_query Query-shaped needle, sv elements normalised. ---! @see eql_v3.jsonb_query -CREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.json) - RETURNS eql_v3.jsonb_query - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT jsonb_build_object( - 'sv', - coalesce( - (SELECT jsonb_agg( - jsonb_strip_nulls( - jsonb_build_object( - 's', elem -> 's', - 'hm', elem -> 'hm', - 'oc', elem -> 'oc' - ) - ) - ) - FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), - '[]'::jsonb - ) - )::eql_v3.jsonb_query -$$; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$; -CREATE CAST (eql_v3.json AS eql_v3.jsonb_query) - WITH FUNCTION eql_v3.to_ste_vec_query - AS ASSIGNMENT; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$; ---! @file v3/sem/ore_cllw/operators.sql ---! @brief Comparison operators on the eql_v3_internal.ore_cllw composite type. ---! ---! Each backing function reduces to a single SELECT over ---! eql_v3_internal.compare_ore_cllw_term(a, b) and is inlinable so the planner can fold ---! it through to functional-index matching. The inner comparator is plpgsql ---! (per-byte loop) and is not inlined — fine for index *match*. ---! ---! @note Deliberately no HASHES / MERGES — the CLLW protocol gives ordering, ---! not a hash; there is no merge-joinable opclass on the other side. ---! @see eql_v3_internal.compare_ore_cllw_term +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Equality backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the CLLW ORE terms are equal ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_eq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 0 -$$; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$; ---! @brief Not-equal backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the CLLW ORE terms are not equal ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_neq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 0 -$$; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$; ---! @brief Less-than backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is less than the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_lt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = -1 -$$; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Less-than-or-equal backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is less than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_lte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 1 -$$; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$; ---! @brief Greater-than backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is greater than the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_gt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 1 -$$; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$; ---! @brief Greater-than-or-equal backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is greater than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_gte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> -1 -$$; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$; -CREATE OPERATOR public.= ( - FUNCTION = eql_v3_internal.ore_cllw_eq, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.=), - NEGATOR = OPERATOR(public.<>), - RESTRICT = eqsel, - JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$; -CREATE OPERATOR public.<> ( - FUNCTION = eql_v3_internal.ore_cllw_neq, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.<>), - NEGATOR = OPERATOR(public.=), - RESTRICT = neqsel, - JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR public.< ( - FUNCTION = eql_v3_internal.ore_cllw_lt, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.>), - NEGATOR = OPERATOR(public.>=), - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$; -CREATE OPERATOR public.<= ( - FUNCTION = eql_v3_internal.ore_cllw_lte, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.>=), - NEGATOR = OPERATOR(public.>), - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR public.> ( - FUNCTION = eql_v3_internal.ore_cllw_gt, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.<), - NEGATOR = OPERATOR(public.<=), - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR public.>= ( - FUNCTION = eql_v3_internal.ore_cllw_gte, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.<=), - NEGATOR = OPERATOR(public.<), - RESTRICT = scalargesel, - JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql ---! @brief Operators for eql_v3.timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param selector text +--! @return public.eql_v3_double_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector text) +RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param selector integer +--! @return public.eql_v3_double_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector integer) +RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a jsonb +--! @param selector public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord) +RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a jsonb +--! @param selector public.eql_v3_double_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); +--! @file encrypted_domain/double/double_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_double_ord_ope. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); +--! @brief Index extractor for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql ---! @brief Operators for eql_v3.timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param selector text +--! @return public.eql_v3_double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector text) +RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param selector integer +--! @return public.eql_v3_double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector integer) +RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param selector public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ope) +RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param selector public.eql_v3_double_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); +--! @file encrypted_domain/double/double_eq_functions.sql +--! @brief Functions for public.eql_v3_double_eq. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer -); +--! @brief Index extractor for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer -); +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_operators.sql ---! @brief Operators for eql_v3.timestamp_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_functions.sql ---! @brief Functions for eql_v3.timestamp. - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector text +--! @return public.eql_v3_double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text) +RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector integer +--! @return public.eql_v3_double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer) +RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. --! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector text ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector text) -RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector integer ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector integer) -RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param selector eql_v3.timestamp ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp) -RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +--! @param selector public.eql_v3_double_eq +--! @return public.eql_v3_double_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq) +RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. --! @param a jsonb ---! @param selector eql_v3.timestamp +--! @param selector public.eql_v3_double_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.eql_v3_double_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_eq_functions.sql ---! @brief Functions for eql_v3.timestamp_eq. +--! @file v3/scalars/date/query_date_types.sql +--! @brief Query-operand domains for date (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Index extractor for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.timestamp_eq) -RETURNS eql_v3_internal.hmac_256 +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_date_ord_ore. + +--! @brief Index extractor for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector text ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector text) -RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text) +RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector integer ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector integer) -RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer) +RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param selector eql_v3.timestamp_eq ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_eq) -RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +--! @param selector public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore) +RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param selector eql_v3.timestamp_eq +--! @param selector public.eql_v3_date_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.eql_v3_date_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_operators.sql ---! @brief Operators for eql_v3.text_search. +--! @file encrypted_domain/date/date_ord_functions.sql +--! @brief Functions for public.eql_v3_date_ord. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param selector text +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text) +RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param selector integer +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer) +RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a jsonb +--! @param selector public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord) +RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a jsonb +--! @param selector public.eql_v3_date_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ore_operators.sql ---! @brief Operators for eql_v3.text_ord_ore. +--! @file encrypted_domain/date/date_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_date_ord_ope. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param selector text +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text) +RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param selector integer +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer) +RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param selector public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope) +RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param selector public.eql_v3_date_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ope_operators.sql ---! @brief Operators for eql_v3.text_ord_ope. +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for public.eql_v3_date_eq. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param selector text +--! @return public.eql_v3_date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text) +RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param selector integer +--! @return public.eql_v3_date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer) +RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param selector public.eql_v3_date_eq +--! @return public.eql_v3_date_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq) +RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param selector public.eql_v3_date_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_operators.sql ---! @brief Operators for eql_v3.text_ord. +--! @file v3/scalars/boolean/boolean_types.sql +--! @brief Encrypted-domain types for boolean. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_boolean. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_boolean AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); + COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file v3/scalars/bigint/query_bigint_types.sql +--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); + COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)'; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); + --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); + COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)'; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); + --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); + COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)'; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); + --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); + COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_bigint_ord_ore. -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Index extractor for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_functions.sql ---! @brief Functions for eql_v3.text. - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.text. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b eql_v3.text +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b eql_v3.text) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b eql_v3.text +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b eql_v3.text) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b eql_v3.text +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector text ---! @return eql_v3.text -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector text) -RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text) +RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector integer ---! @return eql_v3.text -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector integer) -RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer) +RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param selector eql_v3.text ---! @return eql_v3.text -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text) -RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +--! @param selector public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore) +RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param selector eql_v3.text +--! @param selector public.eql_v3_bigint_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b eql_v3.text) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b eql_v3.text +--! @param b public.eql_v3_bigint_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_match_functions.sql ---! @brief Functions for eql_v3.text_match. +--! @file encrypted_domain/bigint/bigint_ord_functions.sql +--! @brief Functions for public.eql_v3_bigint_ord. ---! @brief Index extractor for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.text_match) -RETURNS eql_v3_internal.bloom_filter +--! @brief Index extractor for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.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; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.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; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.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; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.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; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a 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; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a 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; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a 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; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a 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; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a 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; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a 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; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a 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; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a 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; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::eql_v3.text_match) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) @> eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::eql_v3.text_match) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) <@ eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector text ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector text) -RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text) +RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector integer ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector integer) -RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer) +RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param selector eql_v3.text_match ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_match) -RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +--! @param selector public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord) +RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param selector eql_v3.text_match +--! @param selector public.eql_v3_bigint_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_match) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_match, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_match, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_match, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.eql_v3_bigint_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_eq_functions.sql ---! @brief Functions for eql_v3.text_eq. +--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_bigint_ord_ope. ---! @brief Index extractor for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.text_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.text_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector text ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector text) -RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text) +RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector integer ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector integer) -RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer) +RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param selector eql_v3.text_eq ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_eq) -RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +--! @param selector public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope) +RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param selector eql_v3.text_eq +--! @param selector public.eql_v3_bigint_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.eql_v3_bigint_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql ---! @brief Operators for eql_v3.smallint_ord_ore. +--! @file encrypted_domain/bigint/bigint_eq_functions.sql +--! @brief Functions for public.eql_v3_bigint_eq. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector text +--! @return public.eql_v3_bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text) +RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector integer +--! @return public.eql_v3_bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer) +RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_bigint_eq +--! @return public.eql_v3_bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq) +RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_bigint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql ---! @brief Operators for eql_v3.smallint_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @file v3/jsonb/types.sql +--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! Three jsonb-backed domains (none over another domain — operators resolve +--! against the ultimate base type jsonb, so the native-jsonb firewall in +--! blockers.sql can attach): +--! - public.eql_v3_json — storage/root: an EQL envelope object ({i, v, ...}). +--! - public.eql_v3_jsonb_entry — a single sv element (returned by `->`). +--! - eql_v3.query_jsonb — a containment needle (sv elements, no ciphertext). -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Validate a single SteVec entry payload. +--! @internal +--! @param val jsonb Candidate entry payload. +--! @return boolean True when `val` is an sv entry with string `s`, string `c`, +--! and exactly one string deterministic term (`hm` XOR `op`). +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 's') = 'string' + AND jsonb_typeof(val -> 'c') = 'string' + AND ( + (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'op')) + OR + (jsonb_typeof(val -> 'op') = 'string' AND NOT (val ? 'hm')) + ), + false + ) +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Validate a SteVec containment query payload. +--! @internal +--! @param val jsonb Candidate query payload. +--! @return boolean True when `val` is `{"sv":[...]}` and every element carries +--! string `s`, no ciphertext, and exactly one string term (`hm` XOR +--! `op`). +--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the +--! eql_v3.query_jsonb domain CHECK, where a SQL function can never be +--! inlined (and the CHECK itself cannot absorb this body — it needs a +--! subquery over the sv elements, which CHECK constraints forbid). plpgsql +--! caches its plan across calls instead of paying the per-call SQL-function +--! executor on every needle cast. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +AS $$ +BEGIN + RETURN COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT COALESCE(( + jsonb_typeof(elem) = 'object' + AND jsonb_typeof(elem -> 's') = 'string' + AND NOT (elem ? 'c') + AND ( + (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'op')) + OR + (jsonb_typeof(elem -> 'op') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ); +END; +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Validate a root SteVec document payload. +--! @internal +--! @param val jsonb Candidate document payload. +--! @return boolean True when `val` is an encrypted document envelope with +--! `v = 3`, `i`, an `sv` array, and valid sv entry elements. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND val ? 'v' + AND val ->> 'v' = '3' + AND val ? 'i' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem) + ), + false + ) +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Storage/root domain for an encrypted JSONB column. +--! +--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index +--! metadata). Root `c` is intentionally NOT required — an sv-array root payload +--! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` +--! array, so the domain accepts only SteVec **document** payloads and rejects +--! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is +--! what keeps `public.eql_v3_json` a typed document domain rather than a generic +--! encrypted envelope. The firewall in blockers.sql attaches to this domain to +--! stop native jsonb operators from reaching a column value. +--! +--! @note Constructing from inline JSON uses the standard DOMAIN cast: +--! `'{"i":{},"v":3,"sv":[...]}'::public.eql_v3_json`. +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_json AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_document_payload(VALUE) + ); + END IF; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); + COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted JSONB document (containment, equality, ordering)'; +END +$$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Domain type for an individual sv element. +--! +--! A single element inside an `sv` array: a JSON object that carries a selector +--! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for +--! hash-equality) or `op` (CLLW OPE, for ordered queries) — they are mutually +--! exclusive. This is the type returned by `->` and accepted by the per-entry +--! extractors `eql_v3.eq_term` / `eql_v3.ord_term`. Extra fields (`a`, root +--! `i`/`v` merged in by `->`) are allowed. +--! +--! @see src/v3/jsonb/operators.sql +--! +--! @internal +--! Implementation note (issue #354): the CHECK is an INLINE expression, not a +--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain +--! constraints cannot inline SQL functions, so the function-call form paid +--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle +--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured +--! regression on that scenario; see cipherstash/benches#23). The expression +--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the +--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false) +--! would reject NULL, which `->` returns for a missing selector). Keep the +--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins +--! the equivalence. +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_jsonb_entry' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_jsonb_entry AS jsonb + CHECK ( + VALUE IS NULL + OR COALESCE( + jsonb_typeof(VALUE) = 'object' + AND jsonb_typeof(VALUE -> 's') = 'string' + AND jsonb_typeof(VALUE -> 'c') = 'string' + AND ( + (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'op')) + OR + (jsonb_typeof(VALUE -> 'op') = 'string' AND NOT (VALUE ? 'hm')) + ), + false + ) + ); + END IF; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); + COMMENT ON DOMAIN public.eql_v3_jsonb_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; +END +$$; + +--! @brief Domain type for an STE-vec containment needle. +--! +--! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index +--! term but **never** a ciphertext (`c`). Each element must carry `s` and +--! exactly one deterministic term (`hm` XOR `op`). Typing the needle this way +--! stops selector-only needles from casting and matching every row via bare +--! `jsonb @>`. +--! +--! @note Construct from inline JSON via the DOMAIN cast: +--! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.query_jsonb`. +--! @see eql_v3.to_ste_vec_query +--! +--! @internal +--! Implementation note (issue #354): this CHECK CANNOT be inlined like +--! public.eql_v3_jsonb_entry's — validating the sv elements requires a subquery +--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK +--! constraints forbid subqueries. The validator is plpgsql instead (cached +--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql +--! function — the same finding as issue #353), since this cast sits on the +--! per-query hot path of every containment scenario +--! (`$1::jsonb::eql_v3.query_jsonb`). +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_jsonb' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_jsonb AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_query_payload(VALUE) + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_jsonb IS 'EQL JSONB query operand (containment)'; +END +$$; + +--! @brief Convert a public.eql_v3_json to a query_jsonb needle. +--! +--! Normalises each sv element down to the matching-relevant fields: `s` plus +--! exactly one of `hm` / `op`. Other fields (`c`, `a`, `i`/`v`, anything else) +--! are stripped. This is the canonical needle shape for `@>` containment. +--! Designed for use as a functional GIN index expression: +--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. +--! +--! @param e public.eql_v3_json Source encrypted payload +--! @return eql_v3.query_jsonb Query-shaped needle, sv elements normalised. +--! @see eql_v3.query_jsonb +CREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json) + RETURNS eql_v3.query_jsonb + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT jsonb_build_object( + 'sv', + coalesce( + (SELECT jsonb_agg( + jsonb_strip_nulls( + jsonb_build_object( + 's', elem -> 's', + 'hm', elem -> 'hm', + 'op', elem -> 'op' + ) + ) + ) + FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), + '[]'::jsonb + ) + )::eql_v3.query_jsonb +$$; + +CREATE CAST (public.eql_v3_json AS eql_v3.query_jsonb) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_timestamp_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_operators.sql ---! @brief Operators for eql_v3.smallint_ord. +--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_timestamp_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_functions.sql ---! @brief Functions for eql_v3.smallint. +--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql +--! @brief Operators for public.eql_v3_timestamp_ord. ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector text ---! @return eql_v3.smallint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector text) -RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector integer ---! @return eql_v3.smallint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector integer) -RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param selector eql_v3.smallint ---! @return eql_v3.smallint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint) -RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param selector eql_v3.smallint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b eql_v3.smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_eq_functions.sql ---! @brief Functions for eql_v3.smallint_eq. - ---! @brief Index extractor for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.smallint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +--! @file encrypted_domain/timestamp/timestamp_functions.sql +--! @brief Functions for public.eql_v3_timestamp. ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.smallint_eq) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param b eql_v3.smallint_eq +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) = eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.smallint_eq) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param b eql_v3.smallint_eq +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) <> eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param b eql_v3.smallint_eq +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param b eql_v3.smallint_eq +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param b eql_v3.smallint_eq +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param b eql_v3.smallint_eq +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param b eql_v3.smallint_eq +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param b eql_v3.smallint_eq +--! @param b public.eql_v3_timestamp --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param selector text ---! @return eql_v3.smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector text) -RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +--! @return public.eql_v3_timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text) +RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param selector integer ---! @return eql_v3.smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector integer) -RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +--! @return public.eql_v3_timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer) +RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param selector eql_v3.smallint_eq ---! @return eql_v3.smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_eq) -RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +--! @param selector public.eql_v3_timestamp +--! @return public.eql_v3_timestamp +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp) +RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param selector eql_v3.smallint_eq +--! @param selector public.eql_v3_timestamp --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. --! @param a jsonb ---! @param b eql_v3.smallint_eq +--! @param b public.eql_v3_timestamp --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ore_operators.sql ---! @brief Operators for eql_v3.real_ord_ore. +--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_timestamp_ord_ore. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql +--! @brief Functions for eql_v3.query_timestamp_ord. + +--! @brief Index extractor for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_timestamp_ord_ope. + +--! @brief Index extractor for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql +--! @brief Functions for eql_v3.query_timestamp_eq. + +--! @brief Index extractor for eql_v3.query_timestamp_eq. +--! @param a eql_v3.query_timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b eql_v3.query_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a eql_v3.query_timestamp_eq +--! @param b public.eql_v3_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b eql_v3.query_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a eql_v3.query_timestamp_eq +--! @param b public.eql_v3_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_ore_operators.sql +--! @brief Operators for public.eql_v3_text_search_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore + FUNCTION = eql_v3.contains, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3.contains, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore + FUNCTION = eql_v3.contained_by, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3.contained_by, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ope_operators.sql ---! @brief Operators for eql_v3.real_ord_ope. +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for public.eql_v3_text_search. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope + FUNCTION = eql_v3.contains, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb + FUNCTION = eql_v3.contains, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope + FUNCTION = eql_v3.contained_by, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb + FUNCTION = eql_v3.contained_by, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_operators.sql ---! @brief Operators for eql_v3.real_ord. +--! @file encrypted_domain/text/text_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_text_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_ord, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_functions.sql ---! @brief Functions for eql_v3.real. - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/text_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_text_ord_ope. ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector text ---! @return eql_v3.real -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector text) -RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector integer ---! @return eql_v3.real -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector integer) -RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param selector eql_v3.real ---! @return eql_v3.real -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real) -RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param selector eql_v3.real ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b eql_v3.real) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_eq_functions.sql ---! @brief Functions for eql_v3.real_eq. - ---! @brief Index extractor for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.real_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.real_eq) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.real_eq) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector text ---! @return eql_v3.real_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector text) -RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector integer ---! @return eql_v3.real_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector integer) -RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param selector eql_v3.real_eq ---! @return eql_v3.real_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_eq) -RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param selector eql_v3.real_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope +); ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql ---! @brief Operators for eql_v3.numeric_ord_ore. +--! @file encrypted_domain/text/text_ord_operators.sql +--! @brief Operators for public.eql_v3_text_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql ---! @brief Operators for eql_v3.numeric_ord_ope. +--! @file encrypted_domain/text/text_functions.sql +--! @brief Functions for public.eql_v3_text. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector text +--! @return public.eql_v3_text +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text) +RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector integer +--! @return public.eql_v3_text +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer) +RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param selector public.eql_v3_text +--! @return public.eql_v3_text +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text) +RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param selector public.eql_v3_text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @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 -); +--! @file encrypted_domain/text/query_text_search_ore_functions.sql +--! @brief Functions for eql_v3.query_text_search_ore. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Index extractor for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); +--! @file encrypted_domain/text/query_text_search_functions.sql +--! @brief Functions for eql_v3.query_text_search. -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Index extractor for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); +--! @brief Index extractor for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Index extractor for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); +--! @file encrypted_domain/text/query_text_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_text_ord_ore. -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Index extractor for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @file encrypted_domain/numeric/numeric_functions.sql ---! @brief Functions for eql_v3.numeric. +--! @brief Index extractor for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/query_text_ord_functions.sql +--! @brief Functions for eql_v3.query_text_ord. ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb +--! @brief Index extractor for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector text ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector text) -RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector integer ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector integer) -RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/query_text_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_text_ord_ope. ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param selector eql_v3.numeric ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric) -RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param selector eql_v3.numeric ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b eql_v3.numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_eq_functions.sql ---! @brief Functions for eql_v3.numeric_eq. - ---! @brief Index extractor for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.numeric_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.numeric_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_eq) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @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) $$; +--! @file encrypted_domain/text/query_text_match_functions.sql +--! @brief Functions for eql_v3.query_text_match. ---! @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 Index extractor for eql_v3.query_text_match. +--! @param a eql_v3.query_text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for eql_v3.query_text_match. +--! @param a public.eql_v3_text_match +--! @param b eql_v3.query_text_match --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_eq) +CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b eql_v3.query_text_match) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for eql_v3.query_text_match. +--! @param a eql_v3.query_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_match, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_text_match. +--! @param a public.eql_v3_text_match +--! @param b eql_v3.query_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b eql_v3.query_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for eql_v3.query_text_match. +--! @param a eql_v3.query_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector text ---! @return eql_v3.numeric_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector text) -RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector integer ---! @return eql_v3.numeric_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector integer) -RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param selector eql_v3.numeric_eq ---! @return eql_v3.numeric_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_eq) -RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_match, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param selector eql_v3.numeric_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/query_text_eq_functions.sql +--! @brief Functions for eql_v3.query_text_eq. ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_text_eq. +--! @param a eql_v3.query_text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b eql_v3.query_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a eql_v3.query_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b eql_v3.query_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a eql_v3.query_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ore_operators.sql ---! @brief Operators for eql_v3.integer_ord_ore. +--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_smallint_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ope_operators.sql ---! @brief Operators for eql_v3.integer_ord_ope. +--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_smallint_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_operators.sql ---! @brief Operators for eql_v3.integer_ord. +--! @file encrypted_domain/smallint/smallint_ord_operators.sql +--! @brief Operators for public.eql_v3_smallint_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_functions.sql ---! @brief Functions for eql_v3.integer. +--! @file encrypted_domain/smallint/smallint_functions.sql +--! @brief Functions for public.eql_v3_smallint. ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b eql_v3.integer +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b eql_v3.integer +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b eql_v3.integer +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b eql_v3.integer +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b eql_v3.integer +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b eql_v3.integer +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b eql_v3.integer +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b eql_v3.integer +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector text ---! @return eql_v3.integer -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector text) -RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +--! @return public.eql_v3_smallint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text) +RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector integer ---! @return eql_v3.integer -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector integer) -RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +--! @return public.eql_v3_smallint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer) +RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param selector eql_v3.integer ---! @return eql_v3.integer -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer) -RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +--! @param selector public.eql_v3_smallint +--! @return public.eql_v3_smallint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint) +RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param selector eql_v3.integer +--! @param selector public.eql_v3_smallint --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.integer. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b eql_v3.integer +--! @param b public.eql_v3_smallint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_eq_functions.sql ---! @brief Functions for eql_v3.integer_eq. +--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_smallint_ord_ore. ---! @brief Index extractor for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.integer_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b eql_v3.integer_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.integer_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b eql_v3.integer_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.integer_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_eq) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql +--! @brief Functions for eql_v3.query_smallint_ord. + +--! @brief Index extractor for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector text ---! @return eql_v3.integer_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector text) -RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_smallint_ord_ope. ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector integer ---! @return eql_v3.integer_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector integer) -RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param selector eql_v3.integer_eq ---! @return eql_v3.integer_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_eq) -RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param selector eql_v3.integer_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql +--! @brief Functions for eql_v3.query_smallint_eq. ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_smallint_eq. +--! @param a eql_v3.query_smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b eql_v3.query_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_eq. +--! @param a eql_v3.query_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b eql_v3.query_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_smallint_eq. +--! @param a eql_v3.query_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ore_operators.sql ---! @brief Operators for eql_v3.double_ord_ore. +--! @file encrypted_domain/real/real_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_real_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ope_operators.sql ---! @brief Operators for eql_v3.double_ord_ope. +--! @file encrypted_domain/real/real_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_real_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_operators.sql ---! @brief Operators for eql_v3.double_ord. +--! @file encrypted_domain/real/real_ord_operators.sql +--! @brief Operators for public.eql_v3_real_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_functions.sql ---! @brief Functions for eql_v3.double. +--! @file encrypted_domain/real/real_functions.sql +--! @brief Functions for public.eql_v3_real. ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param b eql_v3.double +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param b eql_v3.double +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param b eql_v3.double +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param b eql_v3.double +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param b eql_v3.double +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param b eql_v3.double +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param b eql_v3.double +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param b eql_v3.double +--! @param b public.eql_v3_real --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param selector text ---! @return eql_v3.double -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector text) -RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +--! @return public.eql_v3_real +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text) +RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param selector integer ---! @return eql_v3.double -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector integer) -RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +--! @return public.eql_v3_real +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer) +RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param selector eql_v3.double ---! @return eql_v3.double -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double) -RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +--! @param selector public.eql_v3_real +--! @return public.eql_v3_real +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real) +RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param selector eql_v3.double +--! @param selector public.eql_v3_real --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b eql_v3.double) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.double. +--! @brief Unsupported operator blocker for public.eql_v3_real. --! @param a jsonb ---! @param b eql_v3.double +--! @param b public.eql_v3_real --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_eq_functions.sql ---! @brief Functions for eql_v3.double_eq. +--! @file encrypted_domain/real/query_real_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_real_ord_ore. ---! @brief Index extractor for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.double_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_eq, b eql_v3.double_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.double_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_eq, b eql_v3.double_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_eq, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.double_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_eq) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq +--! @file encrypted_domain/real/query_real_ord_functions.sql +--! @brief Functions for eql_v3.query_real_ord. + +--! @brief Index extractor for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector text ---! @return eql_v3.double_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector text) -RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/query_real_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_real_ord_ope. ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector integer ---! @return eql_v3.double_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector integer) -RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param selector eql_v3.double_eq ---! @return eql_v3.double_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_eq) -RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param selector eql_v3.double_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/query_real_eq_functions.sql +--! @brief Functions for eql_v3.query_real_eq. ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_real_eq. +--! @param a eql_v3.query_real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b eql_v3.query_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a eql_v3.query_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b eql_v3.query_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a eql_v3.query_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @file encrypted_domain/date/date_ord_ore_operators.sql ---! @brief Operators for eql_v3.date_ord_ore. +--! @file v3/sem/ore_block_256/operator_class.sql +--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256. +--! +--! Gives the composite type its DEFAULT btree opclass so the recommended +--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without +--! an explicit opclass annotation (design D4). +--! +--! @note Creating an operator family/class requires superuser: Postgres forbids +--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index +--! integrity. Managed platforms (Supabase, and most hosted Postgres) run +--! the installer as a non-superuser role, so the DO block below ATTEMPTS +--! the creation and skips it on insufficient_privilege (SQLSTATE 42501), +--! letting the single installer run everywhere. When the class is absent, +--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable, +--! but the order-preserving (OPE) ordering domains — whose extractor +--! return types carry a native btree opclass — still index without it. On +--! superuser installs (self-managed Postgres, the SQLx test matrix) the +--! class is created normally. Any non-privilege error still propagates. +--! @see eql_v3_internal.compare_ore_block_256_terms -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +DO $do$ +BEGIN + EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree'; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); + EXECUTE $ddl$ + CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class + DEFAULT FOR TYPE eql_v3_internal.ore_block_256 + USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS + OPERATOR 1 public.<, + OPERATOR 2 public.<=, + OPERATOR 3 public.=, + OPERATOR 4 public.>=, + OPERATOR 5 public.>, + FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) + $ddl$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); + RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class'; +EXCEPTION + WHEN insufficient_privilege THEN + RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected'; +END; +$do$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_numeric_ord_ore. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Index extractor for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql +--! @brief Functions for eql_v3.query_numeric_ord. + +--! @brief Index extractor for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_numeric_ord_ope. + +--! @brief Index extractor for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql +--! @brief Functions for eql_v3.query_numeric_eq. + +--! @brief Index extractor for eql_v3.query_numeric_eq. +--! @param a eql_v3.query_numeric_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b eql_v3.query_numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a eql_v3.query_numeric_eq +--! @param b public.eql_v3_numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b eql_v3.query_numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a eql_v3.query_numeric_eq +--! @param b public.eql_v3_numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_numeric_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_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, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_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, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_ope_operators.sql ---! @brief Operators for eql_v3.date_ord_ope. +--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_numeric_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_operators.sql ---! @brief Operators for eql_v3.date_ord. +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for public.eql_v3_numeric_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_functions.sql ---! @brief Functions for eql_v3.date. +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for public.eql_v3_numeric. ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.eql_v3_numeric --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param selector text ---! @return eql_v3.date -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector text) -RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +--! @return public.eql_v3_numeric +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text) +RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param selector integer ---! @return eql_v3.date -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector integer) -RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +--! @return public.eql_v3_numeric +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer) +RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param selector eql_v3.date ---! @return eql_v3.date -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date) -RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +--! @param selector public.eql_v3_numeric +--! @return public.eql_v3_numeric +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric) +RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param selector eql_v3.date +--! @param selector public.eql_v3_numeric --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.eql_v3_numeric. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.eql_v3_numeric --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_eq_functions.sql ---! @brief Functions for eql_v3.date_eq. +--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_integer_ord_ore. ---! @brief Index extractor for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.date_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.date_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.date_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/integer/query_integer_ord_functions.sql +--! @brief Functions for eql_v3.query_integer_ord. ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector text ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector text) -RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector integer ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector integer) -RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param selector eql_v3.date_eq ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_eq) -RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param selector eql_v3.date_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/boolean/boolean_functions.sql ---! @brief Functions for eql_v3.boolean. +--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_integer_ord_ope. ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/integer/query_integer_eq_functions.sql +--! @brief Functions for eql_v3.query_integer_eq. ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_integer_eq. +--! @param a eql_v3.query_integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b eql_v3.query_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a eql_v3.query_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b eql_v3.query_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a eql_v3.query_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/integer/integer_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_integer_ord_ore. ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector text ---! @return eql_v3.boolean -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector text) -RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector integer ---! @return eql_v3.boolean -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector integer) -RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param selector eql_v3.boolean ---! @return eql_v3.boolean -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.boolean) -RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param selector eql_v3.boolean ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.boolean) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.boolean, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.boolean, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b eql_v3.boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql ---! @brief Operators for eql_v3.bigint_ord_ore. +--! @file encrypted_domain/integer/integer_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_integer_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_operators.sql +--! @brief Operators for public.eql_v3_integer_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_functions.sql +--! @brief Functions for public.eql_v3_integer. + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param selector text +--! @return public.eql_v3_integer +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text) +RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param selector integer +--! @return public.eql_v3_integer +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer) +RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param selector public.eql_v3_integer +--! @return public.eql_v3_integer +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer) +RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param selector public.eql_v3_integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/query_double_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_double_ord_ore. + +--! @brief Index extractor for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/query_double_ord_functions.sql +--! @brief Functions for eql_v3.query_double_ord. + +--! @brief Index extractor for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/query_double_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_double_ord_ope. + +--! @brief Index extractor for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/query_double_eq_functions.sql +--! @brief Functions for eql_v3.query_double_eq. + +--! @brief Index extractor for eql_v3.query_double_eq. +--! @param a eql_v3.query_double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b eql_v3.query_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a eql_v3.query_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b eql_v3.query_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a eql_v3.query_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_double_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_double_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_operators.sql +--! @brief Operators for public.eql_v3_double_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_functions.sql +--! @brief Functions for public.eql_v3_double. + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param selector text +--! @return public.eql_v3_double +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text) +RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param selector integer +--! @return public.eql_v3_double +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer) +RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param selector public.eql_v3_double +--! @return public.eql_v3_double +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double) +RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param selector public.eql_v3_double +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/query_date_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_date_ord_ore. + +--! @brief Index extractor for eql_v3.query_date_ord_ore. +--! @param a eql_v3.query_date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b eql_v3.query_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a eql_v3.query_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b eql_v3.query_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a eql_v3.query_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b eql_v3.query_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a eql_v3.query_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b eql_v3.query_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a eql_v3.query_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b eql_v3.query_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a eql_v3.query_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b eql_v3.query_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ore. +--! @param a eql_v3.query_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/query_date_ord_functions.sql +--! @brief Functions for eql_v3.query_date_ord. + +--! @brief Index extractor for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/query_date_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_date_ord_ope. + +--! @brief Index extractor for eql_v3.query_date_ord_ope. +--! @param a eql_v3.query_date_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b eql_v3.query_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a eql_v3.query_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b eql_v3.query_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a eql_v3.query_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b eql_v3.query_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a eql_v3.query_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b eql_v3.query_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a eql_v3.query_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b eql_v3.query_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a eql_v3.query_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b eql_v3.query_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_ord_ope. +--! @param a eql_v3.query_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/query_date_eq_functions.sql +--! @brief Functions for eql_v3.query_date_eq. + +--! @brief Index extractor for eql_v3.query_date_eq. +--! @param a eql_v3.query_date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b eql_v3.query_date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a eql_v3.query_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b eql_v3.query_date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a eql_v3.query_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_date_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_date_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for public.eql_v3_date_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for public.eql_v3_date. + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param selector text +--! @return public.eql_v3_date +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text) +RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param selector integer +--! @return public.eql_v3_date +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer) +RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param selector public.eql_v3_date +--! @return public.eql_v3_date +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date) +RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param selector public.eql_v3_date +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_functions.sql +--! @brief Functions for public.eql_v3_boolean. + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector text +--! @return public.eql_v3_boolean +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text) +RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector integer +--! @return public.eql_v3_boolean +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer) +RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param selector public.eql_v3_boolean +--! @return public.eql_v3_boolean +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean) +RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param selector public.eql_v3_boolean +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_bigint_ord_ore. + +--! @brief Index extractor for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql +--! @brief Functions for eql_v3.query_bigint_ord. + +--! @brief Index extractor for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_bigint_ord_ope. + +--! @brief Index extractor for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql +--! @brief Functions for eql_v3.query_bigint_eq. + +--! @brief Index extractor for eql_v3.query_bigint_eq. +--! @param a eql_v3.query_bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b eql_v3.query_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a eql_v3.query_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b eql_v3.query_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a eql_v3.query_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_bigint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_bigint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_operators.sql +--! @brief Operators for public.eql_v3_bigint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_functions.sql +--! @brief Functions for public.eql_v3_bigint. + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param selector text +--! @return public.eql_v3_bigint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text) +RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param selector integer +--! @return public.eql_v3_bigint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer) +RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param selector public.eql_v3_bigint +--! @return public.eql_v3_bigint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint) +RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param selector public.eql_v3_bigint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @file v3/jsonb/functions.sql +--! @brief Extractors, containment engine, and path/array functions for the +--! eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! `selector` parameters here are *encrypted-side* selector hashes — the +--! deterministic hash the crypto layer emits in the `s` field of each sv +--! element. Plaintext JSONPaths are never accepted at runtime. + +------------------------------------------------------------------------------ +-- Envelope helpers (eql_v3 owns these; jsonb-only) +------------------------------------------------------------------------------ + +--! @brief Extract metadata (i, v) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return jsonb Metadata object with `i` and `v` fields. +CREATE FUNCTION eql_v3.meta_data(val jsonb) + RETURNS jsonb + IMMUTABLE STRICT PARALLEL SAFE + LANGUAGE SQL +AS $$ + SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); +$$; + +COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS + 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; + +--! @brief Extract ciphertext (c) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text Base64-encoded ciphertext. +--! @throws Exception if `c` is absent. +CREATE FUNCTION eql_v3.ciphertext(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'c' THEN + RETURN val->>'c'; + END IF; + RAISE 'Expected a ciphertext (c) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Selector extractors +------------------------------------------------------------------------------ + +--! @brief Extract selector (s) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text The selector value. +--! @throws Exception if `s` is absent. +CREATE FUNCTION eql_v3.selector(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 's' THEN + RETURN val->>'s'; + END IF; + RAISE 'Expected a selector index (s) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK +--! guarantees `s` is present, so this is a simple field access. +--! @param entry public.eql_v3_jsonb_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry public.eql_v3_jsonb_entry) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 's' +$$; + +------------------------------------------------------------------------------ +-- Equality-term extractor (XOR-aware: coalesce(hm, op)) +------------------------------------------------------------------------------ + +--! @brief XOR-aware equality term extractor for public.eql_v3_jsonb_entry. +--! +--! Returns the bytea of whichever deterministic term the sv entry carries — +--! `hm` (HMAC-256) or `op` (CLLW OPE). The two byte distributions are disjoint +--! by construction, so byte equality on the coalesce is unambiguous. Canonical +--! equality extractor used by `=` / `<>` on jsonb_entry. +--! +--! @param entry public.eql_v3_jsonb_entry +--! @return bytea Decoded `hm` or `op` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_jsonb_entry) + RETURNS bytea + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(coalesce(entry ->> 'hm', entry ->> 'op'), 'hex') +$$; + +------------------------------------------------------------------------------ +-- CLLW OPE per-entry overload (converged with the scalar ord_term) +------------------------------------------------------------------------------ + +--! @brief Extract the CLLW OPE index term from a ste_vec entry. +--! +--! An sv-element `op` term is only ever present on an sv element, never at a +--! root encrypted value, so the typed overload accepts public.eql_v3_jsonb_entry — +--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term` +--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` / +--! `decode` chain propagates it), so btree NULL-filters such rows from range +--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders +--! under native byte comparison with the DEFAULT btree opclass, so a +--! functional index on `eql_v3.ord_term(col -> 'selector')` engages +--! structurally with no custom operator class (Supabase/managed-Postgres +--! safe). +--! +--! @param entry public.eql_v3_jsonb_entry +--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when +--! `op` is absent. +CREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_jsonb_entry) + RETURNS eql_v3_internal.ope_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.ope_cllw(entry::jsonb) +$$; + +------------------------------------------------------------------------------ +-- sv-array helpers +------------------------------------------------------------------------------ + +--! @brief Extract the sv element array as raw jsonb[]. +--! +--! Returns the elements of `sv` (or a single-element array wrapping the value +--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of sv elements. +CREATE FUNCTION eql_v3.ste_vec(val jsonb) + RETURNS jsonb[] + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb; + ary jsonb[]; + BEGIN + IF val ? 'sv' THEN + sv := val->'sv'; + ELSE + sv := jsonb_build_array(val); + END IF; + + SELECT array_agg(elem) + INTO ary + FROM jsonb_array_elements(sv) AS elem; + + RETURN ary; + END; +$$ LANGUAGE plpgsql; + +--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). +--! @param val jsonb encrypted EQL payload +--! @return boolean True if `a` is present and true. +CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'a' THEN + RETURN (val->>'a')::boolean; + END IF; + RETURN false; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Deterministic-fields array for GIN containment +------------------------------------------------------------------------------ + +--! @brief Extract deterministic search fields (s, hm, op) per sv element. +--! +--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can +--! compare for containment. Use for GIN indexes and containment queries. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of objects with only deterministic fields. +CREATE FUNCTION eql_v3.jsonb_array(val jsonb) +RETURNS jsonb[] +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT ARRAY( + SELECT jsonb_object_agg(kv.key, kv.value) + FROM jsonb_array_elements( + CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END + ) AS elem, + LATERAL jsonb_each(elem) AS kv(key, value) + WHERE kv.key IN ('s', 'hm', 'op') + GROUP BY elem + ); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS + 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; + +------------------------------------------------------------------------------ +-- Containment +------------------------------------------------------------------------------ + +--! @brief GIN-indexable containment check: does `a` contain all of `b`? +--! @param a jsonb Container payload. +--! @param b jsonb Search payload. +--! @return boolean True if a contains all deterministic elements of b. +--! @note Public raw-`jsonb[]` containment helper over the extracted +--! deterministic fields — the function-form entrypoint for containment on +--! platforms without operator support (Supabase/PostgREST). The typed +--! `public.eql_v3_json` `@>` operator does NOT call this function — it binds to +--! `eql_v3.ste_vec_contains` instead — but both agree on the result (a +--! parity test pins this). Also the documented GIN index expression +--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. +CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; + +--! @brief GIN-indexable "is contained by" check. +--! @param a jsonb Payload to check. +--! @param b jsonb Container payload. +--! @return boolean True if all elements of a are contained in b. +--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form +--! entrypoint for `<@` on platforms without operator support. The typed +--! `public.eql_v3_json` `<@` operator binds to `eql_v3.ste_vec_contains` instead, +--! but both agree on the result. +CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +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, +--! op)). This collapses the v2 hm/oc CASE: under the XOR contract both terms +--! are deterministic and byte-disjoint, so either one is a valid equality +--! discriminator and a single byte comparison is correct. +--! +--! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and op byte +--! distributions never collide at a given selector. The crypto layer configures +--! a selector for eq XOR ordered, so both sides of a real comparison carry the +--! same term type — an hm needle never meets an op leaf at the same selector. +--! This collapse would wrongly match an hm needle against an op leaf if their +--! hex bytes were ever identical — which the contract prevents (an hm is a +--! fixed 32-byte HMAC; an op is a CLLW OPE ciphertext whose length is a +--! function of the plaintext bit width, never 32 bytes for the supported +--! domains). The negative-containment test guards against regression. +--! +--! @param a jsonb[] sv array to search within. +--! @param b jsonb sv element to search for. +--! @return boolean True if b is found in any element of a. +CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + _a jsonb; + BEGIN + result := false; + + FOR idx IN 1..array_length(a, 1) LOOP + _a := a[idx]; + result := result OR ( + eql_v3.selector(_a) = eql_v3.selector(b) + AND eql_v3.eq_term(_a::public.eql_v3_jsonb_entry) = eql_v3.eq_term(b::public.eql_v3_jsonb_entry) + ); + EXIT WHEN result; + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +--! @brief Does encrypted value `a` contain all sv elements of `b`? +--! +--! Empty b is always contained. Each element of b must match selector + eq_term +--! in some element of a. +--! +--! @param a public.eql_v3_json Container. +--! @param b public.eql_v3_json Elements to find. +--! @return boolean True if all elements of b are contained in a. +--! @see eql_v3.ste_vec_contains(jsonb[], jsonb) +CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json, b public.eql_v3_json) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + sv_a jsonb[]; + sv_b jsonb[]; + _b jsonb; + BEGIN + sv_a := eql_v3.ste_vec(a); + sv_b := eql_v3.ste_vec(b); + + 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; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); + result := true; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); + FOR idx IN 1..array_length(sv_b, 1) LOOP + _b := sv_b[idx]; + result := result AND eql_v3.ste_vec_contains(sv_a, _b); + END LOOP; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); + RETURN result; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +------------------------------------------------------------------------------ +-- Path queries (text selector only) +------------------------------------------------------------------------------ -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Query encrypted JSONB for sv elements matching `selector`. +--! +--! Returns one jsonb_entry row per matching encrypted element. Returns empty +--! set on no match. It deliberately does not wrap multiple matches as an +--! public.eql_v3_json document, because the root document domain requires an `sv` +--! array and single leaves belong to public.eql_v3_jsonb_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF public.eql_v3_jsonb_entry Matching encrypted entries. +--! @see eql_v3.jsonb_path_query_first +CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) + RETURNS SETOF public.eql_v3_jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Check if a selector path exists in encrypted JSONB. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to test. +--! @return boolean True if a matching element exists. +CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT EXISTS ( + SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + ); +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Get the first sv element matching `selector`, or NULL. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to match. +--! @return public.eql_v3_jsonb_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS public.eql_v3_jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + LIMIT 1 +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore -); +------------------------------------------------------------------------------ +-- Array functions +------------------------------------------------------------------------------ -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb -); +--! @brief Get the length of an encrypted JSONB array. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return integer Number of elements. +--! @throws Exception 'cannot get array length of a non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) + RETURNS integer + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF eql_v3_internal.is_ste_vec_array(val) THEN + sv := eql_v3.ste_vec(val); + RETURN array_length(sv, 1); + END IF; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); + RAISE 'cannot get array length of a non-array'; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore -); +--! @brief Extract elements of an encrypted JSONB array as rows. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF public.eql_v3_jsonb_entry One row per element (metadata preserved). +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) + RETURNS SETOF public.eql_v3_jsonb_entry + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + meta jsonb; + item jsonb; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb -); + meta := eql_v3.meta_data(val); + sv := eql_v3.ste_vec(val); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); + FOR idx IN 1..array_length(sv, 1) LOOP + item = sv[idx]; + RETURN NEXT (meta || item)::public.eql_v3_jsonb_entry; + END LOOP; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); + RETURN; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer -); +--! @brief Extract elements of an encrypted JSONB array as ciphertext text. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF text One ciphertext per element. +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) + RETURNS SETOF text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); + sv := eql_v3.ste_vec(val); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); + FOR idx IN 1..array_length(sv, 1) LOOP + RETURN NEXT eql_v3.ciphertext(sv[idx]); + END LOOP; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer -); + RETURN; + END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE +-- Source is src/v3/version.template -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); +DROP FUNCTION IF EXISTS eql_v3.version(); -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); +--! @file v3/version.sql +--! @brief EQL version reporting (self-contained eql_v3 surface) +--! +--! This file is auto-generated from src/v3/version.template during build. +--! The 3.0.0 placeholder is replaced with the actual release +--! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, +--! or "DEV" for development builds. -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Get the installed EQL version string +--! +--! Returns the version string for the installed EQL library. This value is +--! baked in at build time from the release tag. +--! +--! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) +--! +--! @note Auto-generated during build from src/v3/version.template +--! +--! Example: `SELECT eql_v3.version()` returns the installed version string, +--! e.g. `'3.0.0'` (or `'DEV'` for development builds). +CREATE FUNCTION eql_v3.version() + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT '3.0.0'; +$$ LANGUAGE SQL; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Schema-level version marker for obj_description() discoverability +--! +--! Mirrors eql_v3.version() as a comment on the schema so the installed +--! version can also be read via obj_description('eql_v3'::regnamespace). +COMMENT ON SCHEMA eql_v3 IS '3.0.0'; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath -); +--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_timestamp_ord_ore. + +--! @brief State function for min on public.eql_v3_timestamp_ord_ore. +--! @param state public.eql_v3_timestamp_ord_ore +--! @param value public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) +RETURNS public.eql_v3_timestamp_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath +--! @brief min aggregate for public.eql_v3_timestamp_ord_ore. +--! @param input public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_timestamp_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); +--! @brief State function for max on public.eql_v3_timestamp_ord_ore. +--! @param state public.eql_v3_timestamp_ord_ore +--! @param value public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) +RETURNS public.eql_v3_timestamp_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +--! @brief max aggregate for public.eql_v3_timestamp_ord_ore. +--! @param input public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_timestamp_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); +--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_timestamp_ord_ope. + +--! @brief State function for min on public.eql_v3_timestamp_ord_ope. +--! @param state public.eql_v3_timestamp_ord_ope +--! @param value public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) +RETURNS public.eql_v3_timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +--! @brief min aggregate for public.eql_v3_timestamp_ord_ope. +--! @param input public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_timestamp_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); +--! @brief State function for max on public.eql_v3_timestamp_ord_ope. +--! @param state public.eql_v3_timestamp_ord_ope +--! @param value public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) +RETURNS public.eql_v3_timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +--! @brief max aggregate for public.eql_v3_timestamp_ord_ope. +--! @param input public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_timestamp_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore -); +--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_timestamp_ord. + +--! @brief State function for min on public.eql_v3_timestamp_ord. +--! @param state public.eql_v3_timestamp_ord +--! @param value public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) +RETURNS public.eql_v3_timestamp_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +--! @brief min aggregate for public.eql_v3_timestamp_ord. +--! @param input public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_timestamp_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +--! @brief State function for max on public.eql_v3_timestamp_ord. +--! @param state public.eql_v3_timestamp_ord +--! @param value public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) +RETURNS public.eql_v3_timestamp_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.eql_v3_timestamp_ord. +--! @param input public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_timestamp_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql ---! @brief Operators for eql_v3.bigint_ord_ope. +--! @file encrypted_domain/timestamp/timestamp_operators.sql +--! @brief Operators for public.eql_v3_timestamp. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_operators.sql ---! @brief Operators for eql_v3.bigint_ord. +--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql +--! @brief Operators for public.eql_v3_timestamp_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_functions.sql ---! @brief Functions for eql_v3.bigint. - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_timestamp_ord_ore. ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector text ---! @return eql_v3.bigint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector text) -RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector integer ---! @return eql_v3.bigint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector integer) -RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param selector eql_v3.bigint ---! @return eql_v3.bigint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint) -RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql +--! @brief Operators for eql_v3.query_timestamp_ord. ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param selector eql_v3.bigint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_timestamp_ord_ope. ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b eql_v3.bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @file encrypted_domain/bigint/bigint_eq_functions.sql ---! @brief Functions for eql_v3.bigint_eq. +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Index extractor for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.bigint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.bigint_eq) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) = eql_v3.eq_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.bigint_eq) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) <> eql_v3.eq_term(b) $$; +--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql +--! @brief Operators for eql_v3.query_timestamp_eq. ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/text_search_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_search_ore. ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_text_search_ore. +--! @param state public.eql_v3_text_search_ore +--! @param value public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) +RETURNS public.eql_v3_text_search_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_text_search_ore. +--! @param input public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_search_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_text_search_ore. +--! @param state public.eql_v3_text_search_ore +--! @param value public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) +RETURNS public.eql_v3_text_search_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_text_search_ore. +--! @param input public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_search_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_search. + +--! @brief State function for min on public.eql_v3_text_search. +--! @param state public.eql_v3_text_search +--! @param value public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) +RETURNS public.eql_v3_text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_text_search. +--! @param input public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_search, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_text_search. +--! @param state public.eql_v3_text_search +--! @param value public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) +RETURNS public.eql_v3_text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_text_search. +--! @param input public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_search, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/text_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_ord_ore. + +--! @brief State function for min on public.eql_v3_text_ord_ore. +--! @param state public.eql_v3_text_ord_ore +--! @param value public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) +RETURNS public.eql_v3_text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_text_ord_ore. +--! @param input public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_text_ord_ore. +--! @param state public.eql_v3_text_ord_ore +--! @param value public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) +RETURNS public.eql_v3_text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_text_ord_ore. +--! @param input public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/text_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_ord_ope. + +--! @brief State function for min on public.eql_v3_text_ord_ope. +--! @param state public.eql_v3_text_ord_ope +--! @param value public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) +RETURNS public.eql_v3_text_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector text ---! @return eql_v3.bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector text) -RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_text_ord_ope. +--! @param input public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector integer ---! @return eql_v3.bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector integer) -RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_text_ord_ope. +--! @param state public.eql_v3_text_ord_ope +--! @param value public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) +RETURNS public.eql_v3_text_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param selector eql_v3.bigint_eq ---! @return eql_v3.bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_eq) -RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_text_ord_ope. +--! @param input public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/text_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_ord. + +--! @brief State function for min on public.eql_v3_text_ord. +--! @param state public.eql_v3_text_ord +--! @param value public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) +RETURNS public.eql_v3_text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_text_ord. +--! @param input public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param selector eql_v3.bigint_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_text_ord. +--! @param state public.eql_v3_text_ord +--! @param value public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) +RETURNS public.eql_v3_text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_text_ord. +--! @param input public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/text/text_operators.sql +--! @brief Operators for public.eql_v3_text. ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); ---! @file v3/jsonb/functions.sql ---! @brief Extractors, containment engine, and path/array functions for the ---! eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! `selector` parameters here are *encrypted-side* selector hashes — the ---! deterministic hash the crypto layer emits in the `s` field of each sv ---! element. Plaintext JSONPaths are never accepted at runtime. +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); ------------------------------------------------------------------------------- --- Envelope helpers (eql_v3 owns these; jsonb-only) ------------------------------------------------------------------------------- +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); ---! @brief Extract metadata (i, v) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return jsonb Metadata object with `i` and `v` fields. -CREATE FUNCTION eql_v3.meta_data(val jsonb) - RETURNS jsonb - IMMUTABLE STRICT PARALLEL SAFE - LANGUAGE SQL -AS $$ - SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); -$$; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); -COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS - 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); ---! @brief Extract ciphertext (c) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text Base64-encoded ciphertext. ---! @throws Exception if `c` is absent. -CREATE FUNCTION eql_v3.ciphertext(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'c' THEN - RETURN val->>'c'; - END IF; - RAISE 'Expected a ciphertext (c) value in json: %', val; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); ------------------------------------------------------------------------------- --- Selector extractors ------------------------------------------------------------------------------- +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); ---! @brief Extract selector (s) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text The selector value. ---! @throws Exception if `s` is absent. -CREATE FUNCTION eql_v3.selector(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 's' THEN - RETURN val->>'s'; - END IF; - RAISE 'Expected a selector index (s) value in json: %', val; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); ---! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK ---! guarantees `s` is present, so this is a simple field access. ---! @param entry eql_v3.jsonb_entry ---! @return text The selector value. -CREATE FUNCTION eql_v3.selector(entry eql_v3.jsonb_entry) - RETURNS text - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT entry ->> 's' -$$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); ------------------------------------------------------------------------------- --- Equality-term extractor (XOR-aware: coalesce(hm, oc)) ------------------------------------------------------------------------------- +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); ---! @brief XOR-aware equality term extractor for eql_v3.jsonb_entry. ---! ---! Returns the bytea of whichever deterministic term the sv entry carries — ---! `hm` (HMAC-256) or `oc` (CLLW ORE). The two byte distributions are disjoint ---! by construction, so byte equality on the coalesce is unambiguous. Canonical ---! equality extractor used by `=` / `<>` on jsonb_entry. ---! ---! @param entry eql_v3.jsonb_entry ---! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). -CREATE FUNCTION eql_v3.eq_term(entry eql_v3.jsonb_entry) - RETURNS bytea - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT decode(coalesce(entry ->> 'hm', entry ->> 'oc'), 'hex') -$$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); ------------------------------------------------------------------------------- --- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) ------------------------------------------------------------------------------- +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); ---! @brief Extract CLLW ORE index term from a ste_vec entry. ---! ---! `oc` is only ever present on an sv element, never at a root encrypted value, ---! so the typed overload accepts eql_v3.jsonb_entry. Returns SQL NULL when ---! `oc` is absent (btree NULL-filters such rows from range queries). ---! ---! @param entry eql_v3.jsonb_entry ---! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL. ---! @see eql_v3.has_ore_cllw -CREATE FUNCTION eql_v3.ore_cllw(entry eql_v3.jsonb_entry) - RETURNS eql_v3_internal.ore_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN entry ->> 'oc' IS NULL THEN NULL - ELSE ROW(decode(entry ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw - END -$$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); ---! @brief Check if a ste_vec entry contains a CLLW ORE index term. ---! @param entry eql_v3.jsonb_entry ---! @return boolean True if `oc` is present and non-null. -CREATE FUNCTION eql_v3.has_ore_cllw(entry eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT entry ->> 'oc' IS NOT NULL -$$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text, RIGHTARG = text +); ------------------------------------------------------------------------------- --- sv-array helpers ------------------------------------------------------------------------------- +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text, RIGHTARG = integer +); ---! @brief Extract the sv element array as raw jsonb[]. ---! ---! Returns the elements of `sv` (or a single-element array wrapping the value ---! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. ---! ---! @param val jsonb encrypted EQL payload ---! @return jsonb[] Array of sv elements. -CREATE FUNCTION eql_v3.ste_vec(val jsonb) - RETURNS jsonb[] - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb; - ary jsonb[]; - BEGIN - IF val ? 'sv' THEN - sv := val->'sv'; - ELSE - sv := jsonb_build_array(val); - END IF; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); - SELECT array_agg(elem) - INTO ary - FROM jsonb_array_elements(sv) AS elem; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text, RIGHTARG = text +); - RETURN ary; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text, RIGHTARG = integer +); ---! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). ---! @param val jsonb encrypted EQL payload ---! @return boolean True if `a` is present and true. -CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'a' THEN - RETURN (val->>'a')::boolean; - END IF; - RETURN false; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); ------------------------------------------------------------------------------- --- Deterministic-fields array for GIN containment ------------------------------------------------------------------------------- +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_text, RIGHTARG = text +); ---! @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 - ); -$$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_text, RIGHTARG = text[] +); -COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS - 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_text, RIGHTARG = text[] +); ------------------------------------------------------------------------------- --- Containment ------------------------------------------------------------------------------- +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath +); ---! @brief GIN-indexable containment check: does `a` contain all of `b`? ---! @param a jsonb Container payload. ---! @param b jsonb Search payload. ---! @return boolean True if a contains all deterministic elements of b. ---! @note Public raw-`jsonb[]` containment helper over the extracted ---! deterministic fields — the function-form entrypoint for containment on ---! platforms without operator support (Supabase/PostgREST). The typed ---! `eql_v3.json` `@>` operator does NOT call this function — it binds to ---! `eql_v3.ste_vec_contains` instead — but both agree on the result (a ---! parity test pins this). Also the documented GIN index expression ---! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. -CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); -$$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath +); -COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_text, RIGHTARG = text[] +); ---! @brief GIN-indexable "is contained by" check. ---! @param a jsonb Payload to check. ---! @param b jsonb Container payload. ---! @return boolean True if all elements of a are contained in b. ---! @note Public raw-`jsonb[]` reverse-containment helper — the function-form ---! entrypoint for `<@` on platforms without operator support. The typed ---! `eql_v3.json` `<@` operator binds to `eql_v3.ste_vec_contains` instead, ---! but both agree on the result. -CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); -$$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text, RIGHTARG = text[] +); -COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text, RIGHTARG = text +); ---! @brief Check if an sv array contains a specific sv element. ---! ---! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, ---! 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; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text, RIGHTARG = integer +); - FOR idx IN 1..array_length(a, 1) LOOP - _a := a[idx]; - result := result OR ( - eql_v3.selector(_a) = eql_v3.selector(b) - AND eql_v3.eq_term(_a::eql_v3.jsonb_entry) = eql_v3.eq_term(b::eql_v3.jsonb_entry) - ); - EXIT WHEN result; - END LOOP; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text, RIGHTARG = text[] +); - RETURN result; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text, RIGHTARG = text[] +); ---! @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); +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); - IF array_length(sv_b, 1) IS NULL THEN - RETURN true; - END IF; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); - IF array_length(sv_a, 1) IS NULL THEN - RETURN false; - END IF; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); +-- AUTOMATICALLY GENERATED FILE. - result := true; +--! @file encrypted_domain/text/text_match_operators.sql +--! @brief Operators for public.eql_v3_text_match. - FOR idx IN 1..array_length(sv_b, 1) LOOP - _b := sv_b[idx]; - result := result AND eql_v3.ste_vec_contains(sv_a, _b); - END LOOP; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match +); - RETURN result; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb +); ------------------------------------------------------------------------------- --- Path queries (text selector only) ------------------------------------------------------------------------------- +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match +); ---! @brief Query encrypted JSONB for sv elements matching `selector`. ---! ---! Returns one jsonb_entry row per matching encrypted element. Returns empty ---! set on no match. It deliberately does not wrap multiple matches as an ---! eql_v3.json document, because the root document domain requires an `sv` ---! array and single leaves belong to eql_v3.jsonb_entry. ---! ---! @param val jsonb encrypted EQL payload with `sv`. ---! @param selector text Selector hash (`s` value). ---! @return SETOF eql_v3.jsonb_entry Matching encrypted entries. ---! @see eql_v3.jsonb_path_query_first -CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) - RETURNS SETOF eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector -$$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match +); -COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb +); ---! @brief Check if a selector path exists in encrypted JSONB. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to test. ---! @return boolean True if a matching element exists. -CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT EXISTS ( - SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - ); -$$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match +); -COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match +); ---! @brief Get the first sv element matching `selector`, or NULL. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to match. ---! @return eql_v3.jsonb_entry First matching element or NULL. -CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) - RETURNS eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - LIMIT 1 -$$; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb +); -COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match +); ------------------------------------------------------------------------------- --- Array functions ------------------------------------------------------------------------------- +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match +); ---! @brief Get the length of an encrypted JSONB array. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return integer Number of elements. ---! @throws Exception 'cannot get array length of a non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) - RETURNS integer - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF eql_v3_internal.is_ste_vec_array(val) THEN - sv := eql_v3.ste_vec(val); - RETURN array_length(sv, 1); - END IF; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb +); - RAISE 'cannot get array length of a non-array'; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match +); ---! @brief Extract elements of an encrypted JSONB array as rows. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF eql_v3.jsonb_entry One row per element (metadata preserved). ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) - RETURNS SETOF eql_v3.jsonb_entry - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - meta jsonb; - item jsonb; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match +); - meta := eql_v3.meta_data(val); - sv := eql_v3.ste_vec(val); +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb +); - FOR idx IN 1..array_length(sv, 1) LOOP - item = sv[idx]; - RETURN NEXT (meta || item)::eql_v3.jsonb_entry; - END LOOP; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match +); - RETURN; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match +); ---! @brief Extract elements of an encrypted JSONB array as ciphertext text. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF text One ciphertext per element. ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) - RETURNS SETOF text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb +); - sv := eql_v3.ste_vec(val); +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match +); - FOR idx IN 1..array_length(sv, 1) LOOP - RETURN NEXT eql_v3.ciphertext(sv[idx]); - END LOOP; +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); - RETURN; - END; -$$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE --- Source is src/v3/version.template +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); -DROP FUNCTION IF EXISTS eql_v3.version(); +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); ---! @file v3/version.sql ---! @brief EQL version reporting (self-contained eql_v3 surface) ---! ---! This file is auto-generated from src/v3/version.template during build. ---! The 3.0.0-alpha.2 placeholder is replaced with the actual release ---! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, ---! or "DEV" for development builds. +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); ---! @brief Get the installed EQL version string ---! ---! Returns the version string for the installed EQL library. This value is ---! baked in at build time from the release tag. ---! ---! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) ---! ---! @note Auto-generated during build from src/v3/version.template ---! ---! @example ---! -- Check installed EQL version ---! SELECT eql_v3.version(); ---! -- Returns: '3.0.0' -CREATE FUNCTION eql_v3.version() - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT '3.0.0-alpha.2'; -$$ LANGUAGE SQL; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); ---! @brief Schema-level version marker for obj_description() discoverability ---! ---! Mirrors eql_v3.version() as a comment on the schema so the installed ---! version can also be read via obj_description('eql_v3'::regnamespace). -COMMENT ON SCHEMA eql_v3 IS '3.0.0-alpha.2'; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); ---! @file v3/sem/ore_cllw/operator_class.sql ---! @brief Btree operator class on the eql_v3_internal.ore_cllw composite type. ---! ---! DEFAULT FOR TYPE so a functional btree index on eql_v3_internal.ore_cllw(expr) ---! engages without an explicit opclass annotation. FUNCTION 1 is the three-way ---! comparator btree's internal sort uses; it is plpgsql by design (per-byte ---! CLLW protocol needs iteration) and is called once per index-entry pair ---! during build / search, not per-row in the outer query. ---! ---! @note Excluded from the Supabase build variant by the build glob ---! `**/*operator_class.sql`. ---! @see eql_v3_internal.compare_ore_cllw_term - -CREATE OPERATOR FAMILY eql_v3_internal.ore_cllw_ops USING btree; - -CREATE OPERATOR CLASS eql_v3_internal.ore_cllw_ops - DEFAULT FOR TYPE eql_v3_internal.ore_cllw - USING btree FAMILY eql_v3_internal.ore_cllw_ops AS - OPERATOR 1 public.< (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - OPERATOR 2 public.<= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - OPERATOR 3 public.= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - OPERATOR 4 public.>= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - OPERATOR 5 public.> (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - FUNCTION 1 eql_v3_internal.compare_ore_cllw_term(eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw); +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text +); ---! @file v3/sem/ore_block_256/operator_class.sql ---! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256. ---! ---! Gives the composite type its DEFAULT btree opclass so the recommended ---! functional index `CREATE INDEX ON t (eql_v3_internal.ord_term(col))` engages without ---! an explicit opclass annotation (design D4). Excluded from the Supabase build ---! variant by the `**/*operator_class.sql` glob. +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_match, RIGHTARG = integer +); ---! @brief B-tree operator family for ORE block types -CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match +); ---! @brief B-tree operator class for ORE block encrypted values ---! ---! Supports operators: <, <=, =, >=, >. Uses comparison function ---! compare_ore_block_256_terms. -CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class DEFAULT FOR TYPE eql_v3_internal.ore_block_256 USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS - OPERATOR 1 public.<, - OPERATOR 2 public.<=, - OPERATOR 3 public.=, - OPERATOR 4 public.>=, - OPERATOR 5 public.>, - FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256); --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text +); ---! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.timestamp_ord_ore. - ---! @brief State function for min on eql_v3.timestamp_ord_ore. ---! @param state eql_v3.timestamp_ord_ore ---! @param value eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) -RETURNS eql_v3.timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_match, RIGHTARG = integer +); ---! @brief min aggregate for eql_v3.timestamp_ord_ore. ---! @param input eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.timestamp_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); ---! @brief State function for max on eql_v3.timestamp_ord_ore. ---! @param state eql_v3.timestamp_ord_ore ---! @param value eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) -RETURNS eql_v3.timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath +); ---! @brief max aggregate for eql_v3.timestamp_ord_ore. ---! @param input eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.timestamp_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.timestamp_ord_ope. - ---! @brief State function for min on eql_v3.timestamp_ord_ope. ---! @param state eql_v3.timestamp_ord_ope ---! @param value eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) -RETURNS eql_v3.timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] +); ---! @brief min aggregate for eql_v3.timestamp_ord_ope. ---! @param input eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.timestamp_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); ---! @brief State function for max on eql_v3.timestamp_ord_ope. ---! @param state eql_v3.timestamp_ord_ope ---! @param value eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) -RETURNS eql_v3.timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text +); ---! @brief max aggregate for eql_v3.timestamp_ord_ope. ---! @param input eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.timestamp_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_match, RIGHTARG = integer ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql ---! @brief Aggregates for eql_v3.timestamp_ord. - ---! @brief State function for min on eql_v3.timestamp_ord. ---! @param state eql_v3.timestamp_ord ---! @param value eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) -RETURNS eql_v3.timestamp_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] +); ---! @brief min aggregate for eql_v3.timestamp_ord. ---! @param input eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.timestamp_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); ---! @brief State function for max on eql_v3.timestamp_ord. ---! @param state eql_v3.timestamp_ord ---! @param value eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) -RETURNS eql_v3.timestamp_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match +); ---! @brief max aggregate for eql_v3.timestamp_ord. ---! @param input eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.timestamp_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_operators.sql ---! @brief Operators for eql_v3.timestamp. +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for public.eql_v3_text_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer + LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer + LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_search_ore_operators.sql +--! @brief Operators for eql_v3.query_text_search_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_search_operators.sql +--! @brief Operators for eql_v3.query_text_search. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp, RIGHTARG = text +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_eq_operators.sql ---! @brief Operators for eql_v3.timestamp_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/text/query_text_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_text_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +--! @file encrypted_domain/text/query_text_ord_operators.sql +--! @brief Operators for eql_v3.query_text_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +--! @file encrypted_domain/text/query_text_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_text_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +--! @file encrypted_domain/text/query_text_match_operators.sql +--! @brief Operators for eql_v3.query_text_match. + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_aggregates.sql ---! @brief Aggregates for eql_v3.text_search. - ---! @brief State function for min on eql_v3.text_search. ---! @param state eql_v3.text_search ---! @param value eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_search, value eql_v3.text_search) -RETURNS eql_v3.text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @file encrypted_domain/text/query_text_eq_operators.sql +--! @brief Operators for eql_v3.query_text_eq. ---! @brief min aggregate for eql_v3.text_search. ---! @param input eql_v3.text_search ---! @return eql_v3.text_search -CREATE AGGREGATE eql_v3.min(eql_v3.text_search) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_search, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); ---! @brief State function for max on eql_v3.text_search. ---! @param state eql_v3.text_search ---! @param value eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_search, value eql_v3.text_search) -RETURNS eql_v3.text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief max aggregate for eql_v3.text_search. ---! @param input eql_v3.text_search ---! @return eql_v3.text_search -CREATE AGGREGATE eql_v3.max(eql_v3.text_search) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_search, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.text_ord_ore. - ---! @brief State function for min on eql_v3.text_ord_ore. ---! @param state eql_v3.text_ord_ore ---! @param value eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore +--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_smallint_ord_ore. + +--! @brief State function for min on public.eql_v3_smallint_ord_ore. +--! @param state public.eql_v3_smallint_ord_ore +--! @param value public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) +RETURNS public.eql_v3_smallint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -29317,22 +36008,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.text_ord_ore. ---! @param input eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ore) ( +--! @brief min aggregate for public.eql_v3_smallint_ord_ore. +--! @param input public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_ord_ore, + stype = public.eql_v3_smallint_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.text_ord_ore. ---! @param state eql_v3.text_ord_ore ---! @param value eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore +--! @brief State function for max on public.eql_v3_smallint_ord_ore. +--! @param state public.eql_v3_smallint_ord_ore +--! @param value public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) +RETURNS public.eql_v3_smallint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -29344,26 +36035,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.text_ord_ore. ---! @param input eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ore) ( +--! @brief max aggregate for public.eql_v3_smallint_ord_ore. +--! @param input public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_ord_ore, + stype = public.eql_v3_smallint_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.text_ord_ope. - ---! @brief State function for min on eql_v3.text_ord_ope. ---! @param state eql_v3.text_ord_ope ---! @param value eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) -RETURNS eql_v3.text_ord_ope +--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_smallint_ord_ope. + +--! @brief State function for min on public.eql_v3_smallint_ord_ope. +--! @param state public.eql_v3_smallint_ord_ope +--! @param value public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) +RETURNS public.eql_v3_smallint_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -29375,22 +36066,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.text_ord_ope. ---! @param input eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ope) ( +--! @brief min aggregate for public.eql_v3_smallint_ord_ope. +--! @param input public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_ord_ope, + stype = public.eql_v3_smallint_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.text_ord_ope. ---! @param state eql_v3.text_ord_ope ---! @param value eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) -RETURNS eql_v3.text_ord_ope +--! @brief State function for max on public.eql_v3_smallint_ord_ope. +--! @param state public.eql_v3_smallint_ord_ope +--! @param value public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) +RETURNS public.eql_v3_smallint_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -29402,26 +36093,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.text_ord_ope. ---! @param input eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ope) ( +--! @brief max aggregate for public.eql_v3_smallint_ord_ope. +--! @param input public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_ord_ope, + stype = public.eql_v3_smallint_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_aggregates.sql ---! @brief Aggregates for eql_v3.text_ord. - ---! @brief State function for min on eql_v3.text_ord. ---! @param state eql_v3.text_ord ---! @param value eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) -RETURNS eql_v3.text_ord +--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_smallint_ord. + +--! @brief State function for min on public.eql_v3_smallint_ord. +--! @param state public.eql_v3_smallint_ord +--! @param value public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) +RETURNS public.eql_v3_smallint_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -29433,22 +36124,22 @@ BEGIN 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) ( +--! @brief min aggregate for public.eql_v3_smallint_ord. +--! @param input public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_ord, + stype = public.eql_v3_smallint_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.text_ord. ---! @param state eql_v3.text_ord ---! @param value eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) -RETURNS eql_v3.text_ord +--! @brief State function for max on public.eql_v3_smallint_ord. +--! @param state public.eql_v3_smallint_ord +--! @param value public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) +RETURNS public.eql_v3_smallint_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -29460,710 +36151,736 @@ BEGIN 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) ( +--! @brief max aggregate for public.eql_v3_smallint_ord. +--! @param input public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_ord, + stype = public.eql_v3_smallint_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_operators.sql ---! @brief Operators for eql_v3.text. +--! @file encrypted_domain/smallint/smallint_operators.sql +--! @brief Operators for public.eql_v3_smallint. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_match_operators.sql ---! @brief Operators for eql_v3.text_match. +--! @file encrypted_domain/smallint/smallint_eq_operators.sql +--! @brief Operators for public.eql_v3_smallint_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_match, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_match, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_match, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_match, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_match, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_match, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_match, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); -- 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 -); +--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_smallint_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = 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, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql +--! @brief Operators for eql_v3.query_smallint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_eq, RIGHTARG = text +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer +--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_smallint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_eq, RIGHTARG = text +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql +--! @brief Operators for eql_v3.query_smallint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.smallint_ord_ore. - ---! @brief State function for min on eql_v3.smallint_ord_ore. ---! @param state eql_v3.smallint_ord_ore ---! @param value eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) -RETURNS eql_v3.smallint_ord_ore +--! @file encrypted_domain/real/real_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_real_ord_ore. + +--! @brief State function for min on public.eql_v3_real_ord_ore. +--! @param state public.eql_v3_real_ord_ore +--! @param value public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) +RETURNS public.eql_v3_real_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -30175,22 +36892,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.smallint_ord_ore. ---! @param input eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ore) ( +--! @brief min aggregate for public.eql_v3_real_ord_ore. +--! @param input public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.smallint_ord_ore, + stype = public.eql_v3_real_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.smallint_ord_ore. ---! @param state eql_v3.smallint_ord_ore ---! @param value eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) -RETURNS eql_v3.smallint_ord_ore +--! @brief State function for max on public.eql_v3_real_ord_ore. +--! @param state public.eql_v3_real_ord_ore +--! @param value public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) +RETURNS public.eql_v3_real_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -30202,26 +36919,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.smallint_ord_ore. ---! @param input eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ore) ( +--! @brief max aggregate for public.eql_v3_real_ord_ore. +--! @param input public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.smallint_ord_ore, + stype = public.eql_v3_real_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.smallint_ord_ope. - ---! @brief State function for min on eql_v3.smallint_ord_ope. ---! @param state eql_v3.smallint_ord_ope ---! @param value eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) -RETURNS eql_v3.smallint_ord_ope +--! @file encrypted_domain/real/real_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_real_ord_ope. + +--! @brief State function for min on public.eql_v3_real_ord_ope. +--! @param state public.eql_v3_real_ord_ope +--! @param value public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) +RETURNS public.eql_v3_real_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -30233,22 +36950,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.smallint_ord_ope. ---! @param input eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ope) ( +--! @brief min aggregate for public.eql_v3_real_ord_ope. +--! @param input public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.smallint_ord_ope, + stype = public.eql_v3_real_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.smallint_ord_ope. ---! @param state eql_v3.smallint_ord_ope ---! @param value eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) -RETURNS eql_v3.smallint_ord_ope +--! @brief State function for max on public.eql_v3_real_ord_ope. +--! @param state public.eql_v3_real_ord_ope +--! @param value public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) +RETURNS public.eql_v3_real_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -30260,26 +36977,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.smallint_ord_ope. ---! @param input eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ope) ( +--! @brief max aggregate for public.eql_v3_real_ord_ope. +--! @param input public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.smallint_ord_ope, + stype = public.eql_v3_real_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_aggregates.sql ---! @brief Aggregates for eql_v3.smallint_ord. - ---! @brief State function for min on eql_v3.smallint_ord. ---! @param state eql_v3.smallint_ord ---! @param value eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) -RETURNS eql_v3.smallint_ord +--! @file encrypted_domain/real/real_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_real_ord. + +--! @brief State function for min on public.eql_v3_real_ord. +--! @param state public.eql_v3_real_ord +--! @param value public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) +RETURNS public.eql_v3_real_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -30291,22 +37008,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.smallint_ord. ---! @param input eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord) ( +--! @brief min aggregate for public.eql_v3_real_ord. +--! @param input public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.smallint_ord, + stype = public.eql_v3_real_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.smallint_ord. ---! @param state eql_v3.smallint_ord ---! @param value eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) -RETURNS eql_v3.smallint_ord +--! @brief State function for max on public.eql_v3_real_ord. +--! @param state public.eql_v3_real_ord +--! @param value public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) +RETURNS public.eql_v3_real_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -30318,1108 +37035,1124 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.smallint_ord. ---! @param input eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord) ( +--! @brief max aggregate for public.eql_v3_real_ord. +--! @param input public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.smallint_ord, + stype = public.eql_v3_real_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_operators.sql ---! @brief Operators for eql_v3.smallint. +--! @file encrypted_domain/real/real_operators.sql +--! @brief Operators for public.eql_v3_real. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint, RIGHTARG = integer + LEFTARG = public.eql_v3_real, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint, RIGHTARG = integer + LEFTARG = public.eql_v3_real, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint, RIGHTARG = integer + LEFTARG = public.eql_v3_real, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_eq_operators.sql ---! @brief Operators for eql_v3.smallint_eq. +--! @file encrypted_domain/real/real_eq_operators.sql +--! @brief Operators for public.eql_v3_real_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.real_ord_ore. - ---! @brief State function for min on eql_v3.real_ord_ore. ---! @param state eql_v3.real_ord_ore ---! @param value eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) -RETURNS eql_v3.real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @file encrypted_domain/real/query_real_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_real_ord_ore. ---! @brief min aggregate for eql_v3.real_ord_ore. ---! @param input eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.real_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); ---! @brief State function for max on eql_v3.real_ord_ore. ---! @param state eql_v3.real_ord_ore ---! @param value eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) -RETURNS eql_v3.real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.real_ord_ore. ---! @param input eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.real_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.real_ord_ope. - ---! @brief State function for min on eql_v3.real_ord_ope. ---! @param state eql_v3.real_ord_ope ---! @param value eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) -RETURNS eql_v3.real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief min aggregate for eql_v3.real_ord_ope. ---! @param input eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.real_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); ---! @brief State function for max on eql_v3.real_ord_ope. ---! @param state eql_v3.real_ord_ope ---! @param value eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) -RETURNS eql_v3.real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief max aggregate for eql_v3.real_ord_ope. ---! @param input eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.real_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_aggregates.sql ---! @brief Aggregates for eql_v3.real_ord. - ---! @brief State function for min on eql_v3.real_ord. ---! @param state eql_v3.real_ord ---! @param value eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) -RETURNS eql_v3.real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief min aggregate for eql_v3.real_ord. ---! @param input eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE AGGREGATE eql_v3.min(eql_v3.real_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.real_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); ---! @brief State function for max on eql_v3.real_ord. ---! @param state eql_v3.real_ord ---! @param value eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) -RETURNS eql_v3.real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief max aggregate for eql_v3.real_ord. ---! @param input eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE AGGREGATE eql_v3.max(eql_v3.real_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.real_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_operators.sql ---! @brief Operators for eql_v3.real. +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_ord_operators.sql +--! @brief Operators for eql_v3.query_real_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.real, RIGHTARG = jsonb + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.real, RIGHTARG = jsonb + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real, RIGHTARG = jsonb +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_real_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real, RIGHTARG = jsonb + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real, RIGHTARG = jsonb + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real, RIGHTARG = jsonb + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); +--! @file encrypted_domain/real/query_real_eq_operators.sql +--! @brief Operators for eql_v3.query_real_eq. -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real, RIGHTARG = jsonb +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); +--! @file v3/scalars/ore_fallback.sql +--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent (CIP-3468). +--! +--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql, +--! which ATTEMPTS to create the default btree operator class for +--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege +--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud +--! Supabase and most hosted Postgres — run the installer as a non-superuser +--! role). When the class was created, this file is a no-op. +--! +--! When the class was skipped, the ORE-carrying domains would otherwise +--! install half-working: `<`/`>` comparisons still run (as unindexable seq +--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare +--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent +--! degradation, this file poisons every ORE-carrying domain (and its +--! query-operand twin) with an always-raising CHECK constraint, so the first +--! value coerced into the domain fails loudly and points at the +--! platform-supported alternatives (OPE ordering / HMAC equality / +--! bloom-filter match). +--! +--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md): +--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE +--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for +--! NULL inputs, which would silently let NULLs through the poisoned domain). +--! +--! The poison constraints are added NOT VALID. For domains — unlike table +--! constraints — this does not weaken enforcement: coercion applies every +--! constraint regardless of validation status, so new casts and inserts +--! (including NULL) still raise. What it skips is validating existing stored +--! data: without it, re-running the installer over a database that already +--! holds ORE values (written under an earlier superuser install, before the +--! installing role was demoted) would run the always-raising poison against +--! every stored row and abort the install. + +DO $do$ +BEGIN + IF EXISTS ( + SELECT 1 + FROM pg_catalog.pg_opclass c + JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod + WHERE am.amname = 'btree' + AND c.opcdefault + AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype + ) THEN + RETURN; + END IF; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); + --! @brief Poison CHECK backing for the ORE-carrying domains on platforms + --! without the ORE operator class. Always raises; never returns. + --! @internal + CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text) + RETURNS boolean + IMMUTABLE PARALLEL SAFE + SET search_path = pg_catalog, extensions, public + LANGUAGE plpgsql + AS $poison$ + BEGIN + RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name + USING HINT = 'Use ' || alternatives || ' instead.', + ERRCODE = 'feature_not_supported'; + END; + $poison$; + -- NOT VALID: skip validating existing stored data (rows written under an + -- earlier superuser install must stay readable, and re-installing over them + -- must not abort). Domain coercion still enforces the CHECK on every new + -- cast/insert regardless of validation status. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real, RIGHTARG = text -); + ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real, RIGHTARG = integer -); + ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); + ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real, RIGHTARG = text -); + ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real, RIGHTARG = integer -); + ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); + ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real, RIGHTARG = text -); + ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); + ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); + ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real, RIGHTARG = jsonpath -); + ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real, RIGHTARG = jsonpath -); + ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); + ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); + ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real, RIGHTARG = text -); + ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real, RIGHTARG = integer -); + ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); + ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); + ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); + ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); + ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); --- AUTOMATICALLY GENERATED FILE. + ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID; ---! @file encrypted_domain/real/real_eq_operators.sql ---! @brief Operators for eql_v3.real_eq. + RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead'; +END; +$do$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_numeric_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql +--! @brief Operators for eql_v3.query_numeric_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_eq, RIGHTARG = text +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_eq, RIGHTARG = integer +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_eq, RIGHTARG = text +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_eq, RIGHTARG = integer +--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_numeric_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_eq, RIGHTARG = text +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_eq, RIGHTARG = text +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_eq, RIGHTARG = integer +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); +--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql +--! @brief Operators for eql_v3.query_numeric_eq. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.numeric_ord_ore. - ---! @brief State function for min on eql_v3.numeric_ord_ore. ---! @param state eql_v3.numeric_ord_ore ---! @param value eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) -RETURNS eql_v3.numeric_ord_ore +--! @brief Aggregates for public.eql_v3_numeric_ord_ore. + +--! @brief State function for min on public.eql_v3_numeric_ord_ore. +--! @param state public.eql_v3_numeric_ord_ore +--! @param value public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) +RETURNS public.eql_v3_numeric_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -31431,22 +38164,22 @@ BEGIN 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) ( +--! @brief min aggregate for public.eql_v3_numeric_ord_ore. +--! @param input public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.numeric_ord_ore, + stype = public.eql_v3_numeric_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.numeric_ord_ore. ---! @param state eql_v3.numeric_ord_ore ---! @param value eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) -RETURNS eql_v3.numeric_ord_ore +--! @brief State function for max on public.eql_v3_numeric_ord_ore. +--! @param state public.eql_v3_numeric_ord_ore +--! @param value public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) +RETURNS public.eql_v3_numeric_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -31458,26 +38191,26 @@ BEGIN 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) ( +--! @brief max aggregate for public.eql_v3_numeric_ord_ore. +--! @param input public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.numeric_ord_ore, + stype = public.eql_v3_numeric_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.numeric_ord_ope. - ---! @brief State function for min on eql_v3.numeric_ord_ope. ---! @param state eql_v3.numeric_ord_ope ---! @param value eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) -RETURNS eql_v3.numeric_ord_ope +--! @brief Aggregates for public.eql_v3_numeric_ord_ope. + +--! @brief State function for min on public.eql_v3_numeric_ord_ope. +--! @param state public.eql_v3_numeric_ord_ope +--! @param value public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) +RETURNS public.eql_v3_numeric_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -31489,22 +38222,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.numeric_ord_ope. ---! @param input eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ope) ( +--! @brief min aggregate for public.eql_v3_numeric_ord_ope. +--! @param input public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.numeric_ord_ope, + stype = public.eql_v3_numeric_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.numeric_ord_ope. ---! @param state eql_v3.numeric_ord_ope ---! @param value eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) -RETURNS eql_v3.numeric_ord_ope +--! @brief State function for max on public.eql_v3_numeric_ord_ope. +--! @param state public.eql_v3_numeric_ord_ope +--! @param value public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) +RETURNS public.eql_v3_numeric_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -31516,26 +38249,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.numeric_ord_ope. ---! @param input eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ope) ( +--! @brief max aggregate for public.eql_v3_numeric_ord_ope. +--! @param input public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.numeric_ord_ope, + stype = public.eql_v3_numeric_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/numeric/numeric_ord_aggregates.sql ---! @brief Aggregates for eql_v3.numeric_ord. - ---! @brief State function for min on eql_v3.numeric_ord. ---! @param state eql_v3.numeric_ord ---! @param value eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) -RETURNS eql_v3.numeric_ord +--! @brief Aggregates for public.eql_v3_numeric_ord. + +--! @brief State function for min on public.eql_v3_numeric_ord. +--! @param state public.eql_v3_numeric_ord +--! @param value public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) +RETURNS public.eql_v3_numeric_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -31547,22 +38280,22 @@ BEGIN 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) ( +--! @brief min aggregate for public.eql_v3_numeric_ord. +--! @param input public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.numeric_ord, + stype = public.eql_v3_numeric_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.numeric_ord. ---! @param state eql_v3.numeric_ord ---! @param value eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) -RETURNS eql_v3.numeric_ord +--! @brief State function for max on public.eql_v3_numeric_ord. +--! @param state public.eql_v3_numeric_ord +--! @param value public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) +RETURNS public.eql_v3_numeric_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -31574,480 +38307,736 @@ BEGIN 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) ( +--! @brief max aggregate for public.eql_v3_numeric_ord. +--! @param input public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.numeric_ord, + stype = public.eql_v3_numeric_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/numeric/numeric_operators.sql ---! @brief Operators for eql_v3.numeric. +--! @brief Operators for public.eql_v3_numeric. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric, RIGHTARG = text + LEFTARG = public.eql_v3_numeric, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric, RIGHTARG = text + LEFTARG = public.eql_v3_numeric, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric, RIGHTARG = text + LEFTARG = public.eql_v3_numeric, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric, RIGHTARG = text + LEFTARG = public.eql_v3_numeric, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/numeric/numeric_eq_operators.sql ---! @brief Operators for eql_v3.numeric_eq. +--! @brief Operators for public.eql_v3_numeric_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + LEFTARG = jsonb, RIGHTARG = public.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, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_integer_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/query_integer_ord_operators.sql +--! @brief Operators for eql_v3.query_integer_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_integer_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +--! @file encrypted_domain/integer/query_integer_eq_operators.sql +--! @brief Operators for eql_v3.query_integer_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.integer_ord_ore. - ---! @brief State function for min on eql_v3.integer_ord_ore. ---! @param state eql_v3.integer_ord_ore ---! @param value eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) -RETURNS eql_v3.integer_ord_ore +--! @brief Aggregates for public.eql_v3_integer_ord_ore. + +--! @brief State function for min on public.eql_v3_integer_ord_ore. +--! @param state public.eql_v3_integer_ord_ore +--! @param value public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) +RETURNS public.eql_v3_integer_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32059,22 +39048,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.integer_ord_ore. ---! @param input eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ore) ( +--! @brief min aggregate for public.eql_v3_integer_ord_ore. +--! @param input public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.integer_ord_ore, + stype = public.eql_v3_integer_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.integer_ord_ore. ---! @param state eql_v3.integer_ord_ore ---! @param value eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) -RETURNS eql_v3.integer_ord_ore +--! @brief State function for max on public.eql_v3_integer_ord_ore. +--! @param state public.eql_v3_integer_ord_ore +--! @param value public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) +RETURNS public.eql_v3_integer_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32086,26 +39075,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.integer_ord_ore. ---! @param input eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ore) ( +--! @brief max aggregate for public.eql_v3_integer_ord_ore. +--! @param input public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.integer_ord_ore, + stype = public.eql_v3_integer_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.integer_ord_ope. - ---! @brief State function for min on eql_v3.integer_ord_ope. ---! @param state eql_v3.integer_ord_ope ---! @param value eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) -RETURNS eql_v3.integer_ord_ope +--! @brief Aggregates for public.eql_v3_integer_ord_ope. + +--! @brief State function for min on public.eql_v3_integer_ord_ope. +--! @param state public.eql_v3_integer_ord_ope +--! @param value public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) +RETURNS public.eql_v3_integer_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32117,22 +39106,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.integer_ord_ope. ---! @param input eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ope) ( +--! @brief min aggregate for public.eql_v3_integer_ord_ope. +--! @param input public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.integer_ord_ope, + stype = public.eql_v3_integer_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.integer_ord_ope. ---! @param state eql_v3.integer_ord_ope ---! @param value eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) -RETURNS eql_v3.integer_ord_ope +--! @brief State function for max on public.eql_v3_integer_ord_ope. +--! @param state public.eql_v3_integer_ord_ope +--! @param value public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) +RETURNS public.eql_v3_integer_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32144,26 +39133,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.integer_ord_ope. ---! @param input eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ope) ( +--! @brief max aggregate for public.eql_v3_integer_ord_ope. +--! @param input public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.integer_ord_ope, + stype = public.eql_v3_integer_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/integer/integer_ord_aggregates.sql ---! @brief Aggregates for eql_v3.integer_ord. - ---! @brief State function for min on eql_v3.integer_ord. ---! @param state eql_v3.integer_ord ---! @param value eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) -RETURNS eql_v3.integer_ord +--! @brief Aggregates for public.eql_v3_integer_ord. + +--! @brief State function for min on public.eql_v3_integer_ord. +--! @param state public.eql_v3_integer_ord +--! @param value public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) +RETURNS public.eql_v3_integer_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32175,22 +39164,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.integer_ord. ---! @param input eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord) ( +--! @brief min aggregate for public.eql_v3_integer_ord. +--! @param input public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.integer_ord, + stype = public.eql_v3_integer_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.integer_ord. ---! @param state eql_v3.integer_ord ---! @param value eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) -RETURNS eql_v3.integer_ord +--! @brief State function for max on public.eql_v3_integer_ord. +--! @param state public.eql_v3_integer_ord +--! @param value public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) +RETURNS public.eql_v3_integer_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32202,480 +39191,736 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.integer_ord. ---! @param input eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord) ( +--! @brief max aggregate for public.eql_v3_integer_ord. +--! @param input public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.integer_ord, + stype = public.eql_v3_integer_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/integer/integer_operators.sql ---! @brief Operators for eql_v3.integer. +--! @brief Operators for public.eql_v3_integer. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer, RIGHTARG = integer + LEFTARG = public.eql_v3_integer, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer, RIGHTARG = integer + LEFTARG = public.eql_v3_integer, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer, RIGHTARG = integer + LEFTARG = public.eql_v3_integer, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/integer/integer_eq_operators.sql ---! @brief Operators for eql_v3.integer_eq. +--! @brief Operators for public.eql_v3_integer_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/query_double_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_double_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/query_double_ord_operators.sql +--! @brief Operators for eql_v3.query_double_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/query_double_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_double_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); +--! @file encrypted_domain/double/query_double_eq_operators.sql +--! @brief Operators for eql_v3.query_double_eq. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/double/double_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.double_ord_ore. - ---! @brief State function for min on eql_v3.double_ord_ore. ---! @param state eql_v3.double_ord_ore ---! @param value eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) -RETURNS eql_v3.double_ord_ore +--! @brief Aggregates for public.eql_v3_double_ord_ore. + +--! @brief State function for min on public.eql_v3_double_ord_ore. +--! @param state public.eql_v3_double_ord_ore +--! @param value public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) +RETURNS public.eql_v3_double_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32687,22 +39932,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.double_ord_ore. ---! @param input eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ore) ( +--! @brief min aggregate for public.eql_v3_double_ord_ore. +--! @param input public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.double_ord_ore, + stype = public.eql_v3_double_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.double_ord_ore. ---! @param state eql_v3.double_ord_ore ---! @param value eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) -RETURNS eql_v3.double_ord_ore +--! @brief State function for max on public.eql_v3_double_ord_ore. +--! @param state public.eql_v3_double_ord_ore +--! @param value public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) +RETURNS public.eql_v3_double_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32714,26 +39959,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.double_ord_ore. ---! @param input eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ore) ( +--! @brief max aggregate for public.eql_v3_double_ord_ore. +--! @param input public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.double_ord_ore, + stype = public.eql_v3_double_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/double/double_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.double_ord_ope. - ---! @brief State function for min on eql_v3.double_ord_ope. ---! @param state eql_v3.double_ord_ope ---! @param value eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) -RETURNS eql_v3.double_ord_ope +--! @brief Aggregates for public.eql_v3_double_ord_ope. + +--! @brief State function for min on public.eql_v3_double_ord_ope. +--! @param state public.eql_v3_double_ord_ope +--! @param value public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) +RETURNS public.eql_v3_double_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32745,22 +39990,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.double_ord_ope. ---! @param input eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ope) ( +--! @brief min aggregate for public.eql_v3_double_ord_ope. +--! @param input public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.double_ord_ope, + stype = public.eql_v3_double_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.double_ord_ope. ---! @param state eql_v3.double_ord_ope ---! @param value eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) -RETURNS eql_v3.double_ord_ope +--! @brief State function for max on public.eql_v3_double_ord_ope. +--! @param state public.eql_v3_double_ord_ope +--! @param value public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) +RETURNS public.eql_v3_double_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32772,26 +40017,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.double_ord_ope. ---! @param input eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ope) ( +--! @brief max aggregate for public.eql_v3_double_ord_ope. +--! @param input public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.double_ord_ope, + stype = public.eql_v3_double_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/double/double_ord_aggregates.sql ---! @brief Aggregates for eql_v3.double_ord. - ---! @brief State function for min on eql_v3.double_ord. ---! @param state eql_v3.double_ord ---! @param value eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) -RETURNS eql_v3.double_ord +--! @brief Aggregates for public.eql_v3_double_ord. + +--! @brief State function for min on public.eql_v3_double_ord. +--! @param state public.eql_v3_double_ord +--! @param value public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) +RETURNS public.eql_v3_double_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32803,22 +40048,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.double_ord. ---! @param input eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE AGGREGATE eql_v3.min(eql_v3.double_ord) ( +--! @brief min aggregate for public.eql_v3_double_ord. +--! @param input public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.double_ord, + stype = public.eql_v3_double_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.double_ord. ---! @param state eql_v3.double_ord ---! @param value eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) -RETURNS eql_v3.double_ord +--! @brief State function for max on public.eql_v3_double_ord. +--! @param state public.eql_v3_double_ord +--! @param value public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) +RETURNS public.eql_v3_double_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -32830,480 +40075,736 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.double_ord. ---! @param input eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE AGGREGATE eql_v3.max(eql_v3.double_ord) ( +--! @brief max aggregate for public.eql_v3_double_ord. +--! @param input public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.double_ord, + stype = public.eql_v3_double_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/double/double_operators.sql ---! @brief Operators for eql_v3.double. +--! @brief Operators for public.eql_v3_double. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double, RIGHTARG = integer + LEFTARG = public.eql_v3_double, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double, RIGHTARG = integer + LEFTARG = public.eql_v3_double, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double, RIGHTARG = integer + LEFTARG = public.eql_v3_double, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/double/double_eq_operators.sql ---! @brief Operators for eql_v3.double_eq. +--! @brief Operators for public.eql_v3_double_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/query_date_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_date_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/query_date_ord_operators.sql +--! @brief Operators for eql_v3.query_date_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/query_date_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_date_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_eq, RIGHTARG = text +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_eq, RIGHTARG = integer +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); +--! @file encrypted_domain/date/query_date_eq_operators.sql +--! @brief Operators for eql_v3.query_date_eq. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/date/date_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.date_ord_ore. - ---! @brief State function for min on eql_v3.date_ord_ore. ---! @param state eql_v3.date_ord_ore ---! @param value eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) -RETURNS eql_v3.date_ord_ore +--! @brief Aggregates for public.eql_v3_date_ord_ore. + +--! @brief State function for min on public.eql_v3_date_ord_ore. +--! @param state public.eql_v3_date_ord_ore +--! @param value public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) +RETURNS public.eql_v3_date_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33315,22 +40816,22 @@ BEGIN 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) ( +--! @brief min aggregate for public.eql_v3_date_ord_ore. +--! @param input public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.date_ord_ore, + stype = public.eql_v3_date_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.date_ord_ore. ---! @param state eql_v3.date_ord_ore ---! @param value eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) -RETURNS eql_v3.date_ord_ore +--! @brief State function for max on public.eql_v3_date_ord_ore. +--! @param state public.eql_v3_date_ord_ore +--! @param value public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) +RETURNS public.eql_v3_date_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33342,26 +40843,26 @@ BEGIN 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) ( +--! @brief max aggregate for public.eql_v3_date_ord_ore. +--! @param input public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.date_ord_ore, + stype = public.eql_v3_date_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/date/date_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.date_ord_ope. - ---! @brief State function for min on eql_v3.date_ord_ope. ---! @param state eql_v3.date_ord_ope ---! @param value eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) -RETURNS eql_v3.date_ord_ope +--! @brief Aggregates for public.eql_v3_date_ord_ope. + +--! @brief State function for min on public.eql_v3_date_ord_ope. +--! @param state public.eql_v3_date_ord_ope +--! @param value public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) +RETURNS public.eql_v3_date_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33373,22 +40874,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.date_ord_ope. ---! @param input eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ope) ( +--! @brief min aggregate for public.eql_v3_date_ord_ope. +--! @param input public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.date_ord_ope, + stype = public.eql_v3_date_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.date_ord_ope. ---! @param state eql_v3.date_ord_ope ---! @param value eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) -RETURNS eql_v3.date_ord_ope +--! @brief State function for max on public.eql_v3_date_ord_ope. +--! @param state public.eql_v3_date_ord_ope +--! @param value public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) +RETURNS public.eql_v3_date_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33400,26 +40901,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.date_ord_ope. ---! @param input eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ope) ( +--! @brief max aggregate for public.eql_v3_date_ord_ope. +--! @param input public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.date_ord_ope, + stype = public.eql_v3_date_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/date/date_ord_aggregates.sql ---! @brief Aggregates for eql_v3.date_ord. - ---! @brief State function for min on eql_v3.date_ord. ---! @param state eql_v3.date_ord ---! @param value eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) -RETURNS eql_v3.date_ord +--! @brief Aggregates for public.eql_v3_date_ord. + +--! @brief State function for min on public.eql_v3_date_ord. +--! @param state public.eql_v3_date_ord +--! @param value public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) +RETURNS public.eql_v3_date_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33431,22 +40932,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.date_ord. ---! @param input eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE AGGREGATE eql_v3.min(eql_v3.date_ord) ( +--! @brief min aggregate for public.eql_v3_date_ord. +--! @param input public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.date_ord, + stype = public.eql_v3_date_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.date_ord. ---! @param state eql_v3.date_ord ---! @param value eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) -RETURNS eql_v3.date_ord +--! @brief State function for max on public.eql_v3_date_ord. +--! @param state public.eql_v3_date_ord +--! @param value public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) +RETURNS public.eql_v3_date_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33458,704 +40959,960 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.date_ord. ---! @param input eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE AGGREGATE eql_v3.max(eql_v3.date_ord) ( +--! @brief max aggregate for public.eql_v3_date_ord. +--! @param input public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.date_ord, + stype = public.eql_v3_date_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/date/date_operators.sql ---! @brief Operators for eql_v3.date. +--! @brief Operators for public.eql_v3_date. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.date, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.date, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date, RIGHTARG = integer + LEFTARG = public.eql_v3_date, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date, RIGHTARG = integer + LEFTARG = public.eql_v3_date, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date, RIGHTARG = integer + LEFTARG = public.eql_v3_date, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/date/date_eq_operators.sql ---! @brief Operators for eql_v3.date_eq. +--! @brief Operators for public.eql_v3_date_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + LEFTARG = jsonb, RIGHTARG = public.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, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/boolean/boolean_operators.sql ---! @brief Operators for eql_v3.boolean. +--! @brief Operators for public.eql_v3_boolean. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.boolean, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.boolean, RIGHTARG = integer + LEFTARG = public.eql_v3_boolean, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.boolean, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.boolean, RIGHTARG = integer + LEFTARG = public.eql_v3_boolean, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.boolean, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.boolean, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.boolean, RIGHTARG = integer + LEFTARG = public.eql_v3_boolean, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_bigint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql +--! @brief Operators for eql_v3.query_bigint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_bigint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql +--! @brief Operators for eql_v3.query_bigint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.bigint_ord_ore. - ---! @brief State function for min on eql_v3.bigint_ord_ore. ---! @param state eql_v3.bigint_ord_ore ---! @param value eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) -RETURNS eql_v3.bigint_ord_ore +--! @brief Aggregates for public.eql_v3_bigint_ord_ore. + +--! @brief State function for min on public.eql_v3_bigint_ord_ore. +--! @param state public.eql_v3_bigint_ord_ore +--! @param value public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) +RETURNS public.eql_v3_bigint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34167,22 +41924,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.bigint_ord_ore. ---! @param input eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ore) ( +--! @brief min aggregate for public.eql_v3_bigint_ord_ore. +--! @param input public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.bigint_ord_ore, + stype = public.eql_v3_bigint_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.bigint_ord_ore. ---! @param state eql_v3.bigint_ord_ore ---! @param value eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) -RETURNS eql_v3.bigint_ord_ore +--! @brief State function for max on public.eql_v3_bigint_ord_ore. +--! @param state public.eql_v3_bigint_ord_ore +--! @param value public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) +RETURNS public.eql_v3_bigint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34194,26 +41951,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.bigint_ord_ore. ---! @param input eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ore) ( +--! @brief max aggregate for public.eql_v3_bigint_ord_ore. +--! @param input public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.bigint_ord_ore, + stype = public.eql_v3_bigint_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.bigint_ord_ope. - ---! @brief State function for min on eql_v3.bigint_ord_ope. ---! @param state eql_v3.bigint_ord_ope ---! @param value eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) -RETURNS eql_v3.bigint_ord_ope +--! @brief Aggregates for public.eql_v3_bigint_ord_ope. + +--! @brief State function for min on public.eql_v3_bigint_ord_ope. +--! @param state public.eql_v3_bigint_ord_ope +--! @param value public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) +RETURNS public.eql_v3_bigint_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34225,22 +41982,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.bigint_ord_ope. ---! @param input eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ope) ( +--! @brief min aggregate for public.eql_v3_bigint_ord_ope. +--! @param input public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.bigint_ord_ope, + stype = public.eql_v3_bigint_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.bigint_ord_ope. ---! @param state eql_v3.bigint_ord_ope ---! @param value eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) -RETURNS eql_v3.bigint_ord_ope +--! @brief State function for max on public.eql_v3_bigint_ord_ope. +--! @param state public.eql_v3_bigint_ord_ope +--! @param value public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) +RETURNS public.eql_v3_bigint_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34252,26 +42009,26 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.bigint_ord_ope. ---! @param input eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ope) ( +--! @brief max aggregate for public.eql_v3_bigint_ord_ope. +--! @param input public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.bigint_ord_ope, + stype = public.eql_v3_bigint_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/bigint/bigint_ord_aggregates.sql ---! @brief Aggregates for eql_v3.bigint_ord. - ---! @brief State function for min on eql_v3.bigint_ord. ---! @param state eql_v3.bigint_ord ---! @param value eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) -RETURNS eql_v3.bigint_ord +--! @brief Aggregates for public.eql_v3_bigint_ord. + +--! @brief State function for min on public.eql_v3_bigint_ord. +--! @param state public.eql_v3_bigint_ord +--! @param value public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) +RETURNS public.eql_v3_bigint_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34283,22 +42040,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.bigint_ord. ---! @param input eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord) ( +--! @brief min aggregate for public.eql_v3_bigint_ord. +--! @param input public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.bigint_ord, + stype = public.eql_v3_bigint_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.bigint_ord. ---! @param state eql_v3.bigint_ord ---! @param value eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) -RETURNS eql_v3.bigint_ord +--! @brief State function for max on public.eql_v3_bigint_ord. +--! @param state public.eql_v3_bigint_ord +--! @param value public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) +RETURNS public.eql_v3_bigint_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34310,468 +42067,468 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.bigint_ord. ---! @param input eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord) ( +--! @brief max aggregate for public.eql_v3_bigint_ord. +--! @param input public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.bigint_ord, + stype = public.eql_v3_bigint_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/bigint/bigint_operators.sql ---! @brief Operators for eql_v3.bigint. +--! @brief Operators for public.eql_v3_bigint. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/bigint/bigint_eq_operators.sql ---! @brief Operators for eql_v3.bigint_eq. +--! @brief Operators for public.eql_v3_bigint_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); --! @brief EQL lint: detect non-inlinable operator implementation functions @@ -34793,7 +42550,7 @@ CREATE OPERATOR || ( --! (or `pg_get_functiondef`); tracked as a follow-up. --! --! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and ---! the SEM index-term types `eql_v3_internal.ore_block_256`, `eql_v3_internal.ore_cllw`) whose +--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose --! implementation functions fail any of these rules silently fall back to seq --! scan when the documented functional indexes (`eql_v3.eq_term(col)`, --! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. @@ -34857,9 +42614,29 @@ RETURNS TABLE ( LANGUAGE sql STABLE AS $$ WITH - -- All operators where at least one operand is an `eql_v3` type. Limits - -- the scope of the lint to the operator surface customers actually hit - -- via SQL (`col = val`, `col @> '...'` and friends). + -- User-column encrypted domains now live in public so application tables + -- survive EQL uninstall. Keep this separate from owned_schemas(): public is + -- not installer-owned, but its EQL jsonb-backed domains are still the domain + -- types whose blockers/operator surfaces the lint must understand. + encrypted_domain_types AS ( + SELECT + dt.oid AS typid + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND bt.typname = 'jsonb' + AND bn.nspname = 'pg_catalog' + AND ( + dn.nspname = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ), + + -- All operators where at least one operand is an EQL-owned type or a public + -- encrypted domain. Limits the scope of the lint to the operator surface + -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends). eql_operators AS ( SELECT op.oid AS oprid, @@ -34872,7 +42649,10 @@ AS $$ WHERE EXISTS ( SELECT 1 FROM pg_type t WHERE t.oid IN (op.oprleft, op.oprright) - AND t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) + AND ( + t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) + OR t.oid IN (SELECT typid FROM encrypted_domain_types) + ) ) ), @@ -34900,7 +42680,7 @@ AS $$ -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the -- literal `is not supported for` for older path-operator blockers) AND - -- that take at least one `eql_v3` domain over jsonb argument. The argument + -- that take at least one encrypted domain over jsonb argument. The argument -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` -- helpers themselves, which contain the marker in their body but are not -- blockers (they take text arguments, not a domain). @@ -34919,12 +42699,7 @@ AS $$ AND EXISTS ( SELECT 1 FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) - JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - WHERE dt.typtype = 'd' - AND bt.typname = 'jsonb' - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + JOIN encrypted_domain_types edt ON edt.typid = arg.typ ) ) @@ -35102,7 +42877,7 @@ AS $$ WHERE dt.typtype = 'd' AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) AND bt.typtype = 'd' - AND bn.nspname = ANY(eql_v3_internal.owned_schemas()) + AND bt.oid IN (SELECT typid FROM encrypted_domain_types) -- ┌─────────────────────────────────────────────────────────────────┐ -- │ Domain opclass: an operator class declared FOR TYPE on an │ @@ -35123,8 +42898,7 @@ AS $$ JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace - WHERE t.typtype = 'd' - AND tn.nspname = ANY(eql_v3_internal.owned_schemas()) + WHERE t.oid IN (SELECT typid FROM encrypted_domain_types) -- ┌─────────────────────────────────────────────────────────────────┐ -- │ Schema placement: the public `eql_v3` schema must hold only the │ @@ -35158,7 +42932,7 @@ COMMENT ON FUNCTION eql_v3.lints() IS 'eligible for planner inlining.'; --! @file v3/jsonb/operators.sql ---! @brief Operators on eql_v3.json and eql_v3.jsonb_entry. +--! @brief Operators on public.eql_v3_json and public.eql_v3_jsonb_entry. ------------------------------------------------------------------------------ -- -> field accessor (returns jsonb_entry) @@ -35172,20 +42946,20 @@ COMMENT ON FUNCTION eql_v3.lints() IS --! 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` +--! 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` +--! typically NULL), NOT this operator: PostgreSQL reduces the `public.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 e public.eql_v3_json Root encrypted payload. --! @param selector text Selector hash. ---! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector text) - RETURNS eql_v3.jsonb_entry +--! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.eql_v3_json, selector text) + RETURNS public.eql_v3_jsonb_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT ( @@ -35195,40 +42969,40 @@ AS $$ '$.sv[*] ? (@.s == $sel)'::jsonpath, jsonb_build_object('sel', selector) ) - )::eql_v3.jsonb_entry + )::public.eql_v3_jsonb_entry $$; CREATE OPERATOR ->( FUNCTION=eql_v3."->", - LEFTARG=eql_v3.json, + LEFTARG=public.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 e public.eql_v3_json Encrypted sv-array payload. --! @param selector integer Array index. ---! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector integer) - RETURNS eql_v3.jsonb_entry +--! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.eql_v3_json, selector integer) + RETURNS public.eql_v3_jsonb_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT CASE WHEN eql_v3_internal.is_ste_vec_array(e) THEN -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an - -- unknown-typed literal, so `e -> 'sv'` already flattens `eql_v3.json` to + -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json` to -- its base type and binds native `jsonb -> text` (see the @warning above) — - -- the custom `->(eql_v3.json, text)` operator does NOT capture a bare + -- the custom `->(public.eql_v3_json, text)` operator does NOT capture a bare -- untyped literal. The cast documents that intent and guards the `-> selector` - -- (integer) hop from ever resolving to the v3 `->(eql_v3.json, integer)` + -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json, integer)` -- operator instead of native array access. - (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::eql_v3.jsonb_entry + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_jsonb_entry ELSE NULL END $$; CREATE OPERATOR ->( FUNCTION=eql_v3."->", - LEFTARG=eql_v3.json, + LEFTARG=public.eql_v3_json, RIGHTARG=integer ); @@ -35242,10 +43016,10 @@ CREATE OPERATOR ->( --! Intentional v2 parity: this serializes the entire matched jsonb_entry --! object as JSON text. It does not decrypt or return scalar plaintext like --! native `jsonb ->>`. ---! @param e eql_v3.json Encrypted payload. +--! @param e public.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) +CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json, selector text) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35254,16 +43028,16 @@ $$; CREATE OPERATOR ->> ( FUNCTION=eql_v3."->>", - LEFTARG=eql_v3.json, + LEFTARG=public.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 e public.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) +CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json, selector integer) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35272,7 +43046,7 @@ $$; CREATE OPERATOR ->> ( FUNCTION=eql_v3."->>", - LEFTARG=eql_v3.json, + LEFTARG=public.eql_v3_json, RIGHTARG=integer ); @@ -35281,11 +43055,11 @@ CREATE OPERATOR ->> ( ------------------------------------------------------------------------------ --! @brief @> contains operator (document, document). ---! @param a eql_v3.json Container. ---! @param b eql_v3.json Contained value. +--! @param a public.eql_v3_json Container. +--! @param b public.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) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35294,19 +43068,19 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.json + LEFTARG=public.eql_v3_json, + RIGHTARG=public.eql_v3_json ); ---! @brief @> contains operator with an jsonb_query needle. +--! @brief @> contains operator with an query_jsonb needle. --! --! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a --! functional GIN index on the same expression engages. --! ---! @param a eql_v3.json Container. ---! @param b eql_v3.jsonb_query Query payload. +--! @param a public.eql_v3_json Container. +--! @param b eql_v3.query_jsonb Query payload. --! @return boolean True if a contains b. -CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_query) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b eql_v3.query_jsonb) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35315,8 +43089,8 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.jsonb_query + LEFTARG=public.eql_v3_json, + RIGHTARG=eql_v3.query_jsonb ); --! @brief @> contains operator with a single jsonb_entry needle. @@ -35324,10 +43098,10 @@ CREATE OPERATOR @>( --! Wraps the entry into a single-element sv array (stripping `c`) and reduces --! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form. --! ---! @param a eql_v3.json Container. ---! @param b eql_v3.jsonb_entry Single entry. +--! @param a public.eql_v3_json Container. +--! @param b public.eql_v3_jsonb_entry Single entry. --! @return boolean True if a contains an sv entry matching b. -CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_entry) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b public.eql_v3_jsonb_entry) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35339,7 +43113,7 @@ AS $$ jsonb_build_object( 's', b -> 's', 'hm', b -> 'hm', - 'oc', b -> 'oc' + 'op', b -> 'op' ) ) ) @@ -35348,8 +43122,8 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.jsonb_entry + LEFTARG=public.eql_v3_json, + RIGHTARG=public.eql_v3_jsonb_entry ); ------------------------------------------------------------------------------ @@ -35357,10 +43131,10 @@ CREATE OPERATOR @>( ------------------------------------------------------------------------------ --! @brief <@ contained-by operator (document, document). ---! @param a eql_v3.json Contained value. ---! @param b eql_v3.json Container. +--! @param a public.eql_v3_json Contained value. +--! @param b public.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) +CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35369,15 +43143,15 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.json + LEFTARG=public.eql_v3_json, + RIGHTARG=public.eql_v3_json ); ---! @brief <@ contained-by operator with an jsonb_query LHS. ---! @param a eql_v3.jsonb_query Query payload. ---! @param b eql_v3.json Container. +--! @brief <@ contained-by operator with an query_jsonb LHS. +--! @param a eql_v3.query_jsonb Query payload. +--! @param b public.eql_v3_json Container. --! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_query, b eql_v3.json) +CREATE FUNCTION eql_v3."<@"(a eql_v3.query_jsonb, b public.eql_v3_json) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35386,15 +43160,15 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.jsonb_query, - RIGHTARG=eql_v3.json + LEFTARG=eql_v3.query_jsonb, + RIGHTARG=public.eql_v3_json ); --! @brief <@ contained-by operator with a jsonb_entry LHS. ---! @param a eql_v3.jsonb_entry Single entry. ---! @param b eql_v3.json Container. +--! @param a public.eql_v3_jsonb_entry Single entry. +--! @param b public.eql_v3_json Container. --! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_entry, b eql_v3.json) +CREATE FUNCTION eql_v3."<@"(a public.eql_v3_jsonb_entry, b public.eql_v3_json) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35403,19 +43177,19 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.jsonb_entry, - RIGHTARG=eql_v3.json + LEFTARG=public.eql_v3_jsonb_entry, + RIGHTARG=public.eql_v3_json ); ------------------------------------------------------------------------------ -- jsonb_entry comparisons ------------------------------------------------------------------------------ ---! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand +--! @brief Equality on jsonb_entry via eq_term (hm-or-op byte equality). +--! @param a public.eql_v3_jsonb_entry Left operand +--! @param b public.eql_v3_jsonb_entry Right operand --! @return boolean True if the entries are equal -CREATE FUNCTION eql_v3.eq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35424,8 +43198,8 @@ $$; CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, + LEFTARG = public.eql_v3_jsonb_entry, + RIGHTARG = public.eql_v3_jsonb_entry, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, @@ -35433,10 +43207,10 @@ CREATE OPERATOR = ( ); --! @brief Inequality on jsonb_entry via eq_term. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand +--! @param a public.eql_v3_jsonb_entry Left operand +--! @param b public.eql_v3_jsonb_entry Right operand --! @return boolean True if the entries are not equal -CREATE FUNCTION eql_v3.neq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -35445,92 +43219,92 @@ $$; CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, + LEFTARG = public.eql_v3_jsonb_entry, + RIGHTARG = public.eql_v3_jsonb_entry, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); ---! @brief Less-than on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand +--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order). +--! @param a public.eql_v3_jsonb_entry Left operand +--! @param b public.eql_v3_jsonb_entry Right operand --! @return boolean True if a is less than b -CREATE FUNCTION eql_v3.lt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.ore_cllw(a) < eql_v3.ore_cllw(b) + SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, + LEFTARG = public.eql_v3_jsonb_entry, + RIGHTARG = public.eql_v3_jsonb_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); ---! @brief Less-than-or-equal on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand +--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term. +--! @param a public.eql_v3_jsonb_entry Left operand +--! @param b public.eql_v3_jsonb_entry Right operand --! @return boolean True if a is less than or equal to b -CREATE FUNCTION eql_v3.lte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.ore_cllw(a) <= eql_v3.ore_cllw(b) + SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, + LEFTARG = public.eql_v3_jsonb_entry, + RIGHTARG = public.eql_v3_jsonb_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); ---! @brief Greater-than on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand +--! @brief Greater-than on jsonb_entry via the CLLW OPE term. +--! @param a public.eql_v3_jsonb_entry Left operand +--! @param b public.eql_v3_jsonb_entry Right operand --! @return boolean True if a is greater than b -CREATE FUNCTION eql_v3.gt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.ore_cllw(a) > eql_v3.ore_cllw(b) + SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, + LEFTARG = public.eql_v3_jsonb_entry, + RIGHTARG = public.eql_v3_jsonb_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); ---! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand +--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term. +--! @param a public.eql_v3_jsonb_entry Left operand +--! @param b public.eql_v3_jsonb_entry Right operand --! @return boolean True if a is greater than or equal to b -CREATE FUNCTION eql_v3.gte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.ore_cllw(a) >= eql_v3.ore_cllw(b) + SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, + LEFTARG = public.eql_v3_jsonb_entry, + RIGHTARG = public.eql_v3_jsonb_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, @@ -35538,10 +43312,10 @@ CREATE OPERATOR >= ( ); --! @file v3/jsonb/blockers.sql ---! @brief Native-jsonb firewall for eql_v3.json. +--! @brief Native-jsonb firewall for public.eql_v3_json. --! ---! eql_v3.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons ---! = <> < <= > >= are supported on eql_v3.jsonb_entry only, not on the root +--! public.eql_v3_json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on public.eql_v3_jsonb_entry only, not on the root --! document domain. --! Every OTHER native jsonb operator reachable via domain fallback against the --! base type jsonb is BLOCKED here so an encrypted column can never silently @@ -35559,417 +43333,417 @@ CREATE OPERATOR >= ( --! so the firewall fires. --! @brief Blocker: ? (key/element exists). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a eql_v3.json, b text) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ? ( FUNCTION = eql_v3_internal.jsonb_blocked_exists, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = text ); --! @brief Blocker: ?| (any key exists). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a eql_v3.json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?|'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?|'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = text[] ); --! @brief Blocker: ?& (all keys exist). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a eql_v3.json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?&'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?&'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = text[] ); --! @brief Blocker: @? (jsonpath exists). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a eql_v3.json, b jsonpath) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@?'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @? ( FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath ); --! @brief Blocker: @@ (jsonpath predicate). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a eql_v3.json, b jsonpath) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath ); --! @brief Blocker: #> (path extract, native returns jsonb). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a eql_v3.json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #> ( FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = text[] ); --! @brief Blocker: #>> (path extract as text). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return text Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a eql_v3.json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_text('eql_v3.json', '#>>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json', '#>>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = text[] ); --! @brief Blocker: - (delete key, text RHS; native returns jsonb). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a eql_v3.json, b text) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = text ); --! @brief Blocker: - (delete index, integer RHS). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b integer Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a eql_v3.json, b integer) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = integer ); --! @brief Blocker: - (delete keys, text[] RHS). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a eql_v3.json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = text[] ); --! @brief Blocker: #- (delete at path). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a eql_v3.json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #- ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = text[] ); --! @brief Blocker: || (concatenate, encrypted on the left). ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a eql_v3.json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( FUNCTION = eql_v3_internal.jsonb_blocked_concat, - LEFTARG = eql_v3.json, + LEFTARG = public.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). +--! @param b public.eql_v3_json Right operand (encrypted payload). --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b eql_v3.json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, LEFTARG = jsonb, - RIGHTARG = eql_v3.json + RIGHTARG = public.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). +--! @brief Blocker: root public.eql_v3_json document comparisons. +--! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param b public.eql_v3_json Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a eql_v3.json, b eql_v3.json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.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). +--! @brief Blocker: root public.eql_v3_json-to-jsonb comparisons. +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a eql_v3.json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); END; $$ LANGUAGE plpgsql; ---! @brief Blocker: root jsonb-to-eql_v3.json comparisons. +--! @brief Blocker: root jsonb-to-public.eql_v3_json comparisons. --! @param a jsonb Native LHS operand. ---! @param b eql_v3.json Right operand (encrypted payload). +--! @param b public.eql_v3_json Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b eql_v3.json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + LEFTARG = public.eql_v3_json, + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = eql_v3.json + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + LEFTARG = public.eql_v3_json, + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = eql_v3.json + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + LEFTARG = public.eql_v3_json, + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = eql_v3.json + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + LEFTARG = public.eql_v3_json, + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = eql_v3.json + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + LEFTARG = public.eql_v3_json, + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = eql_v3.json + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + LEFTARG = public.eql_v3_json, + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = eql_v3.json + RIGHTARG = public.eql_v3_json ); ------------------------------------------------------------------------------ @@ -35977,193 +43751,195 @@ CREATE OPERATOR >= ( ------------------------------------------------------------------------------ --! @brief Blocker: @> with encrypted root document and native jsonb. ---! @param a eql_v3.json Left operand (encrypted payload). +--! @param a public.eql_v3_json Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a eql_v3.json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.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). +--! @param b public.eql_v3_json Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b eql_v3.json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.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 a public.eql_v3_json Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a eql_v3.json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.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). +--! @param b public.eql_v3_json Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b eql_v3.json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, LEFTARG = jsonb, - RIGHTARG = eql_v3.json + RIGHTARG = public.eql_v3_json ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, - LEFTARG = eql_v3.json, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, LEFTARG = jsonb, - RIGHTARG = eql_v3.json + RIGHTARG = public.eql_v3_json ); --! @file v3/jsonb/aggregates.sql ---! @brief min / max aggregates over eql_v3.jsonb_entry. +--! @brief min / max aggregates over public.eql_v3_jsonb_entry. --! --! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by ---! their CLLW ORE (`oc`) term, so the extremum is picked by comparing ---! `eql_v3.ore_cllw(entry)` rather than the scalar Block-ORE `ord_term` the ---! generated scalar ord aggregates use. Same STRICT + PARALLEL SAFE shape as the ---! generated scalar `min`/`max` so partial/parallel aggregation is available on ---! large GROUP BY workloads. +--! their CLLW OPE (`op`) term, so the extremum is picked by comparing +--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the +--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under +--! native byte comparison, so `<` / `>` on the extracted terms needs no custom +--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar +--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY +--! workloads. --! --! Per the encrypted-domain footgun rules the state functions are --! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would --! be inlinable and the planner could elide it. --! ---! @note **Only `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 +--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)` +--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a +--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions +--! therefore IGNORE `op`-less entries (they never become or survive as the +--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and +--! `op`-less entries and is not corrupted by an `op`-less seed. A naive +--! `ord_term(value) < ord_term(state)` would be NULL whenever either side +--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated +--! row is `op`-less. An all-`op`-less input has no orderable extremum and --! returns the (arbitrary) STRICT seed. ---! @brief State function for min on eql_v3.jsonb_entry. +--! @brief State function for min on public.eql_v3_jsonb_entry. --! ---! Keeps whichever orderable entry has the lesser CLLW ORE term. STRICT, so SQL ---! NULL entries are skipped by the aggregate machinery; `oc`-less (non-orderable) +--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL +--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable) --! entries are skipped explicitly (see the @note on this file). --! ---! @param state eql_v3.jsonb_entry Running extremum. ---! @param value eql_v3.jsonb_entry Candidate entry. ---! @return eql_v3.jsonb_entry The lesser orderable entry by `ore_cllw`. +--! @param state public.eql_v3_jsonb_entry Running extremum. +--! @param value public.eql_v3_jsonb_entry Candidate entry. +--! @return public.eql_v3_jsonb_entry The lesser orderable entry by `ord_term`. CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( - state eql_v3.jsonb_entry, - value eql_v3.jsonb_entry + state public.eql_v3_jsonb_entry, + value public.eql_v3_jsonb_entry ) -RETURNS eql_v3.jsonb_entry +RETURNS public.eql_v3_jsonb_entry LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ DECLARE - value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); - state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); + value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); + state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); BEGIN - -- A non-orderable (oc-less) candidate never replaces the running extremum. - IF value_ore IS NULL THEN + -- A non-orderable (op-less) candidate never replaces the running extremum. + IF value_ope IS NULL THEN RETURN state; END IF; -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an oc-less STRICT seed) or strictly greater. - IF state_ore IS NULL OR value_ore < state_ore THEN + -- (e.g. an op-less STRICT seed) or strictly greater. + IF state_ope IS NULL OR value_ope < state_ope THEN RETURN value; END IF; RETURN state; END; $$; ---! @brief min aggregate over eql_v3.jsonb_entry. ---! @param input eql_v3.jsonb_entry ---! @return eql_v3.jsonb_entry The entry with the smallest CLLW ORE term. -CREATE AGGREGATE eql_v3.min(eql_v3.jsonb_entry) ( +--! @brief min aggregate over public.eql_v3_jsonb_entry. +--! @param input public.eql_v3_jsonb_entry +--! @return public.eql_v3_jsonb_entry The entry with the smallest CLLW OPE term. +CREATE AGGREGATE eql_v3.min(public.eql_v3_jsonb_entry) ( sfunc = eql_v3_internal.jsonb_entry_min_sfunc, - stype = eql_v3.jsonb_entry, + stype = public.eql_v3_jsonb_entry, combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.jsonb_entry. +--! @brief State function for max on public.eql_v3_jsonb_entry. --! ---! Keeps whichever orderable entry has the greater CLLW ORE term. `oc`-less +--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less --! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). --! ---! @param state eql_v3.jsonb_entry Running extremum. ---! @param value eql_v3.jsonb_entry Candidate entry. ---! @return eql_v3.jsonb_entry The greater orderable entry by `ore_cllw`. +--! @param state public.eql_v3_jsonb_entry Running extremum. +--! @param value public.eql_v3_jsonb_entry Candidate entry. +--! @return public.eql_v3_jsonb_entry The greater orderable entry by `ord_term`. CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( - state eql_v3.jsonb_entry, - value eql_v3.jsonb_entry + state public.eql_v3_jsonb_entry, + value public.eql_v3_jsonb_entry ) -RETURNS eql_v3.jsonb_entry +RETURNS public.eql_v3_jsonb_entry LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ DECLARE - value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); - state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); + value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); + state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); BEGIN - -- A non-orderable (oc-less) candidate never replaces the running extremum. - IF value_ore IS NULL THEN + -- A non-orderable (op-less) candidate never replaces the running extremum. + IF value_ope IS NULL THEN RETURN state; END IF; -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an oc-less STRICT seed) or strictly lesser. - IF state_ore IS NULL OR value_ore > state_ore THEN + -- (e.g. an op-less STRICT seed) or strictly lesser. + IF state_ope IS NULL OR value_ope > state_ope THEN RETURN value; END IF; RETURN state; END; $$; ---! @brief max aggregate over eql_v3.jsonb_entry. ---! @param input eql_v3.jsonb_entry ---! @return eql_v3.jsonb_entry The entry with the largest CLLW ORE term. -CREATE AGGREGATE eql_v3.max(eql_v3.jsonb_entry) ( +--! @brief max aggregate over public.eql_v3_jsonb_entry. +--! @param input public.eql_v3_jsonb_entry +--! @return public.eql_v3_jsonb_entry The entry with the largest CLLW OPE term. +CREATE AGGREGATE eql_v3.max(public.eql_v3_jsonb_entry) ( sfunc = eql_v3_internal.jsonb_entry_max_sfunc, - stype = eql_v3.jsonb_entry, + stype = public.eql_v3_jsonb_entry, combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, parallel = safe ); @@ -36179,10 +43955,10 @@ CREATE AGGREGATE eql_v3.max(eql_v3.jsonb_entry) ( --! satisfying Supabase splinter's `function_search_path_mutable` lint. --! --! @note A SET clause disables SQL-function inlining. The inline-critical SEM ---! helpers (ore_block_256_*, ore_cllw_*, ore_cllw/has_ore_cllw, ---! ope_cllw, hmac_256, bloom_filter over jsonb) and the ---! encrypted-domain family (recognised structurally) are deliberately ---! left unpinned. +--! helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over +--! jsonb) and the encrypted-domain family (recognised structurally, +--! including public user-column domains) are deliberately left +--! unpinned. --! @see tasks/test/splinter.sh --! @see tasks/build.sh @@ -36213,13 +43989,6 @@ BEGIN AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq', 'ore_block_256_lt', 'ore_block_256_lte', 'ore_block_256_gt', 'ore_block_256_gte')) - OR (p.pronargs = 2 - AND p.proname IN ('ore_cllw_eq', 'ore_cllw_neq', - 'ore_cllw_lt', 'ore_cllw_lte', - 'ore_cllw_gt', 'ore_cllw_gte')) - OR (p.pronargs = 1 - AND p.proname IN ('ore_cllw', 'has_ore_cllw') - AND p.proargtypes[0] = jsonb_oid) -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a -- domain over bytea (native comparison operators and btree opclass), -- so there are no ope-specific comparison functions to keep inlinable. @@ -36246,7 +44015,9 @@ BEGIN ) AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[]))) -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE, - -- taking >=1 argument typed as a jsonb-backed DOMAIN in eql_v3. + -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column + -- domains live in public; implementation-only domains live in EQL-owned + -- schemas. AND NOT ( p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l WHERE l.lanname = 'sql') @@ -36258,7 +44029,10 @@ BEGIN JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace WHERE dt.typtype = 'd' AND dt.typbasetype = jsonb_oid - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + AND ( + dn.nspname = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) ) ) -- Comment-marker fallback for hand-written inline-critical extension diff --git a/packages/drizzle/__tests__/operators.test.ts b/packages/drizzle/__tests__/operators.test.ts index 41b174b0e..e88c75a48 100644 --- a/packages/drizzle/__tests__/operators.test.ts +++ b/packages/drizzle/__tests__/operators.test.ts @@ -454,3 +454,33 @@ describe('Batched and/or operators', () => { expect(condition).toBeTruthy() }) }) + +// ============================================================================ +// bigint rejection — the EQL v2 integration cannot carry a native bigint +// (`@cipherstash/protect`'s query term type is `JsPlaintext | null`), so a +// bigint must fail loudly rather than silently coerce to the text "1". +// ============================================================================ + +describe('bigint values are rejected on the EQL v2 integration', () => { + it('gt throws ProtectOperatorError instead of silently stringifying a bigint', async () => { + const { protectOps } = setup() + + // `age` has orderAndRange, so `gt` takes the encrypting path and reaches + // `toPlaintext`, where a bigint must be rejected. + await expect( + protectOps.gt(usersTable.age, 1n as unknown as number), + ).rejects.toThrow(ProtectOperatorError) + await expect( + protectOps.gt(usersTable.age, 1n as unknown as number), + ).rejects.toThrow(/bigint values are not supported/) + }) + + it('never reaches the encrypt client when rejecting a bigint', async () => { + const { protectOps, encryptQuery } = setup() + + await expect( + protectOps.gt(usersTable.age, 1n as unknown as number), + ).rejects.toThrow(ProtectOperatorError) + expect(encryptQuery).not.toHaveBeenCalled() + }) +}) diff --git a/packages/drizzle/src/pg/operators.ts b/packages/drizzle/src/pg/operators.ts index 8c0a2cf21..358bb3318 100644 --- a/packages/drizzle/src/pg/operators.ts +++ b/packages/drizzle/src/pg/operators.ts @@ -251,6 +251,17 @@ function toPlaintext(value: unknown): string | number { if (value instanceof Date) { return value.toISOString() } + if (typeof value === 'bigint') { + // Reject rather than fall through to `String(value)` below: a stringified + // bigint would be silently encrypted as text and mismatch its column. The + // EQL v2 `@cipherstash/protect` query API types its plaintext as + // `JsPlaintext | null`, which cannot carry a native bigint, so bigint + // columns are unsupported on this integration — fail loudly instead of + // corrupting. (EQL v3 bigint columns are supported via `@cipherstash/stack`.) + throw new ProtectOperatorError( + 'bigint values are not supported for encrypted columns in the EQL v2 Drizzle integration; use @cipherstash/stack for EQL v3 bigint columns', + ) + } return String(value) } diff --git a/packages/migrate/README.md b/packages/migrate/README.md index 37eb8a5c1..a4fa2959e 100644 --- a/packages/migrate/README.md +++ b/packages/migrate/README.md @@ -14,6 +14,8 @@ schema-added → dual-writing → backfilling → backfilled → cut-over → dr State is tracked in an append-only `cipherstash.cs_migrations` table installed by `stash eql install`. The EQL intent (which indexes, which cast_as) continues to live in `eql_v2_configuration` so Proxy continues to work against the same database. +> **This package targets EQL v2.** The lifecycle above wraps `eql_v2.*` functions and reads and writes `eql_v2_configuration`. `stash eql install` installs v2 by default; EQL v3 is opt-in via `stash eql install --eql-version 3`, installs via the direct path only, and encodes its configuration in each column's domain type rather than in a configuration table. Columns installed under v3 are not covered by this package's migration lifecycle. + ## API ```ts diff --git a/packages/prisma-next/test/cipherstash-codec.test.ts b/packages/prisma-next/test/cipherstash-codec.test.ts index 07896f6f6..3375bf4c6 100644 --- a/packages/prisma-next/test/cipherstash-codec.test.ts +++ b/packages/prisma-next/test/cipherstash-codec.test.ts @@ -124,7 +124,10 @@ describe('planFieldEventOperations driving the cipherstash hook', () => { storage: new SqlStorage({ storageHash: 'sha256:test' as StorageHashBase, namespaces: { - __unbound__: buildSqlNamespace({ id: '__unbound__', entries: { table: tables } }), + __unbound__: buildSqlNamespace({ + id: '__unbound__', + entries: { table: tables }, + }), }, }), domain: { namespaces: { __unbound__: { models: {} } } }, diff --git a/packages/prisma-next/test/descriptor.test.ts b/packages/prisma-next/test/descriptor.test.ts index 6956128cd..96cfe2df6 100644 --- a/packages/prisma-next/test/descriptor.test.ts +++ b/packages/prisma-next/test/descriptor.test.ts @@ -121,7 +121,8 @@ describe('cipherstash extension descriptor (contract-space package layout)', () headRefHash: space.headRef.hash, // The emit pipeline hashes through the SQL family's // canonicalization hooks; the recompute must use the same ones. - shouldPreserveEmpty: sqlContractCanonicalizationHooks.shouldPreserveEmpty, + shouldPreserveEmpty: + sqlContractCanonicalizationHooks.shouldPreserveEmpty, sortStorage: sqlContractCanonicalizationHooks.sortStorage, }), ).not.toThrow() diff --git a/packages/prisma-next/test/operator-lowering-equality.test.ts b/packages/prisma-next/test/operator-lowering-equality.test.ts index f74290ffe..694d0759b 100644 --- a/packages/prisma-next/test/operator-lowering-equality.test.ts +++ b/packages/prisma-next/test/operator-lowering-equality.test.ts @@ -116,9 +116,7 @@ describe('cipherstash operator lowering — equality extensions', () => { `"SELECT "user"."id" AS "id" FROM "user" WHERE NOT eql_v2.eq("user"."email", $1::eql_v2_encrypted)"`, ) expect(lowered.params).toHaveLength(1) - expect(literalParamValue(lowered.params[0])).toBeInstanceOf( - EncryptedString, - ) + expect(literalParamValue(lowered.params[0])).toBeInstanceOf(EncryptedString) }) it('lowers cipherstashInArray with a single element to a one-term OR', () => { diff --git a/packages/prisma-next/test/operator-lowering.test.ts b/packages/prisma-next/test/operator-lowering.test.ts index 3ec1038f2..6d276bb76 100644 --- a/packages/prisma-next/test/operator-lowering.test.ts +++ b/packages/prisma-next/test/operator-lowering.test.ts @@ -145,9 +145,7 @@ describe('cipherstash operator lowering — per-codec envelope dispatch', () => const lowered = makeAdapter().lower(selectWithWhere(predicate), { contract, }) - expect(literalParamValue(lowered.params[0])).toBeInstanceOf( - EncryptedBigInt, - ) + expect(literalParamValue(lowered.params[0])).toBeInstanceOf(EncryptedBigInt) }) it('cipherstashGt on a date column wraps the value in EncryptedDate', () => { diff --git a/packages/schema/src/index.ts b/packages/schema/src/index.ts index 9fa80ef08..1b61526a3 100644 --- a/packages/schema/src/index.ts +++ b/packages/schema/src/index.ts @@ -67,6 +67,7 @@ const arrayIndexModeSchema = z.union([ const steVecIndexOptsSchema = z.object({ prefix: z.string(), array_index_mode: arrayIndexModeSchema.optional(), + mode: z.enum(['compat', 'standard']).optional(), }) const indexesSchema = z @@ -232,7 +233,17 @@ export class ProtectColumn { */ searchableJson() { this.castAsValue = 'json' - this.indexesValue.ste_vec = { prefix: 'enabled', array_index_mode: 'all' } + // `mode: 'standard'` pins the per-entry ordering term to CLLW-ORE (`oc`), + // the only encoding the eql_v2 SQL compares. protect-ffi 0.29 flipped the + // library default to `compat` (CLLW-OPE, `op`) for EQL v3; without the pin + // every v2 containment query silently matches nothing — and existing v2 + // rows encrypted under `standard` are not cross-comparable with `compat` + // anyway, so this also keeps the v2 wire format byte-stable. + this.indexesValue.ste_vec = { + prefix: 'enabled', + array_index_mode: 'all', + mode: 'standard', + } return this } diff --git a/packages/stack-drizzle/README.md b/packages/stack-drizzle/README.md new file mode 100644 index 000000000..91f6ec00e --- /dev/null +++ b/packages/stack-drizzle/README.md @@ -0,0 +1,77 @@ +# @cipherstash/stack-drizzle + +Drizzle ORM integration for [CipherStash Stack](https://www.npmjs.com/package/@cipherstash/stack) — +searchable, application-layer field-level encryption for PostgreSQL. + +Depends on `@cipherstash/stack`; install both: + +```bash +npm install @cipherstash/stack @cipherstash/stack-drizzle drizzle-orm +``` + +## EQL v3 (`/v3` subpath) + +Each encrypted column is a concrete `public.eql_v3_*` Postgres domain whose query +capabilities are fixed by the `types.*` factory you choose — no per-column config +object. Install the domains once with `stash eql install --eql-version 3`. + +```ts +import { pgTable, integer } from 'drizzle-orm/pg-core' +import { EncryptionV3 } from '@cipherstash/stack/v3' +import { + types as encryptedTypes, + extractEncryptionSchemaV3, + createEncryptionOperatorsV3, +} from '@cipherstash/stack-drizzle/v3' + +const users = pgTable('users', { + id: integer('id').primaryKey().generatedAlwaysAsIdentity(), + email: encryptedTypes.TextSearch('email'), // equality + order/range + free-text + age: encryptedTypes.IntegerOrd('age'), // equality + order/range +}) + +const schema = extractEncryptionSchemaV3(users) +const client = await EncryptionV3({ schemas: [schema] }) +const ops = createEncryptionOperatorsV3(client) + +// Insert — encrypt models first +const enc = await client.bulkEncryptModels( + [{ email: 'alice@example.com', age: 30 }], + schema, +) +if (!enc.failure) await db.insert(users).values(enc.data) + +// Query — operators auto-encrypt their plaintext operands +const rows = await db + .select() + .from(users) + .where(await ops.and( + ops.contains(users.email, 'alice'), // free-text containment over ciphertext + ops.between(users.age, 18, 65), + )) + .orderBy(ops.asc(users.age)) + +// Decrypt after select +const dec = await client.bulkDecryptModels(rows, schema) +``` + +## EQL v2 (package root) — legacy + +The v2 integration predates the typed v3 domains and is kept for existing +projects. New projects should use v3 above. + +```ts +import { encryptedType, extractEncryptionSchema, createEncryptionOperators } from '@cipherstash/stack-drizzle' +import { Encryption } from '@cipherstash/stack' +``` + +`encryptedType` defines an `eql_v2_encrypted` column; `createEncryptionOperators` +returns query operators (`eq`, `like`, `gt`, `inArray`, …) that transparently +encrypt search values. + +## Docs + +Full guide: https://cipherstash.com/docs/integrations/drizzle — see also the +bundled `stash-drizzle` agent skill. + +> Not to be confused with `@cipherstash/drizzle`, the older `@cipherstash/protect`-based package. diff --git a/packages/stack-drizzle/__tests__/drizzle-operators-bigint.test.ts b/packages/stack-drizzle/__tests__/drizzle-operators-bigint.test.ts new file mode 100644 index 000000000..e71e47622 --- /dev/null +++ b/packages/stack-drizzle/__tests__/drizzle-operators-bigint.test.ts @@ -0,0 +1,59 @@ +import type { EncryptionClient } from '@cipherstash/stack/encryption' +import { PgDialect, pgTable } from 'drizzle-orm/pg-core' +import { describe, expect, it, vi } from 'vitest' +import { createEncryptionOperators, encryptedType } from '../src/index.js' + +// Regression coverage for the `bigint` (int8) plaintext path through the v3 +// Drizzle operators. Before the fix, `toPlaintext` fell through to +// `String(value)`, so `ops.eq(bigintCol, 1n)` was encrypted as the TEXT "1" and +// silently mismatched the column's bigint domain. The operators must forward a +// native `bigint` to `encryptQuery` (whose term type is `Plaintext`), so +// protect-ffi 0.28 encrypts it against the int8 domain and bounds-checks it. + +const ENCRYPTED_VALUE = '{"v":"encrypted-value"}' + +function setup() { + const encryptQuery = vi.fn(async (termsOrValue: unknown) => + Array.isArray(termsOrValue) + ? { data: termsOrValue.map(() => ENCRYPTED_VALUE) } + : { data: ENCRYPTED_VALUE }, + ) + const client = { encryptQuery } as unknown as EncryptionClient + const encryptionOps = createEncryptionOperators(client) + const dialect = new PgDialect() + return { encryptQuery, encryptionOps, dialect } +} + +const accounts = pgTable('accounts', { + balance: encryptedType('balance', { + dataType: 'bigint', + equality: true, + orderAndRange: true, + }), +}) + +describe('Drizzle v3 operators preserve bigint plaintext (int8 columns)', () => { + it('eq forwards a native bigint to encryptQuery, not a String()-coerced value', async () => { + const { encryptQuery, encryptionOps } = setup() + + await encryptionOps.eq(accounts.balance, 1n) + + expect(encryptQuery).toHaveBeenCalledTimes(1) + const terms = encryptQuery.mock.calls[0]?.[0] as Array<{ value: unknown }> + expect(terms).toHaveLength(1) + expect(typeof terms[0]?.value).toBe('bigint') + expect(terms[0]?.value).toBe(1n) + // The pre-fix bug: a stringified bigint. + expect(terms[0]?.value).not.toBe('1') + }) + + it('preserves i64 boundary magnitudes losslessly (beyond Number.MAX_SAFE_INTEGER)', async () => { + const { encryptQuery, encryptionOps } = setup() + const big = 9223372036854775807n // i64::MAX + + await encryptionOps.gt(accounts.balance, big) + + const terms = encryptQuery.mock.calls[0]?.[0] as Array<{ value: unknown }> + expect(terms[0]?.value).toBe(big) + }) +}) diff --git a/packages/stack/__tests__/drizzle-operators-jsonb.test.ts b/packages/stack-drizzle/__tests__/drizzle-operators-jsonb.test.ts similarity index 98% rename from packages/stack/__tests__/drizzle-operators-jsonb.test.ts rename to packages/stack-drizzle/__tests__/drizzle-operators-jsonb.test.ts index 2f3f5658e..47ab6bce0 100644 --- a/packages/stack/__tests__/drizzle-operators-jsonb.test.ts +++ b/packages/stack-drizzle/__tests__/drizzle-operators-jsonb.test.ts @@ -1,11 +1,11 @@ +import type { EncryptionClient } from '@cipherstash/stack/encryption' import { PgDialect, pgTable } from 'drizzle-orm/pg-core' import { describe, expect, it, vi } from 'vitest' import { createEncryptionOperators, EncryptionOperatorError, encryptedType, -} from '@/drizzle' -import type { EncryptionClient } from '@/encryption' +} from '../src/index.js' const ENCRYPTED_VALUE = '{"v":"encrypted-value"}' diff --git a/packages/stack-drizzle/__tests__/v3/bigint.test.ts b/packages/stack-drizzle/__tests__/v3/bigint.test.ts new file mode 100644 index 000000000..6a7298170 --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/bigint.test.ts @@ -0,0 +1,111 @@ +import { type SQL, sql } from 'drizzle-orm' +import { integer, PgDialect, pgTable } from 'drizzle-orm/pg-core' +import { describe, expect, it, vi } from 'vitest' +import { getEqlV3Column, isEqlV3Column } from '../../src/v3/column' +import { + createEncryptionOperatorsV3, + EncryptionOperatorError, +} from '../../src/v3/operators' +import { types } from '../../src/v3/types' + +// A representative query TERM — what `client.encryptQuery` returns for a bigint +// operand: a ciphertext-free term, deliberately NOT a plaintext bigint. +const TERM = { hm: 'h', v: 3 } +const TERM_JSON = JSON.stringify(TERM) + +function chainable(result: unknown) { + const op = result as { + withLockContext: ReturnType + audit: ReturnType + } + op.withLockContext = vi.fn(() => op) + op.audit = vi.fn(() => op) + return op +} + +function setup() { + const encryptQuery = vi.fn(() => chainable(Promise.resolve({ data: TERM }))) + const ops = createEncryptionOperatorsV3({ encryptQuery }) + const dialect = new PgDialect() + const render = (s: SQL) => dialect.sqlToQuery(s) + return { ops, encryptQuery, render } +} + +// A statically-typed table via the drizzle `types` namespace (no dynamic +// matrix, no casts) — the column set is known at compile time. +const accounts = pgTable('accounts', { + id: integer().primaryKey(), + balance: types.BigintOrd('balance'), + ledgerId: types.BigintEq('ledger_id'), + archived: types.Bigint('archived'), +}) + +describe('v3 drizzle bigint columns', () => { + it('detects a bigint column and reports its concrete public.eql_v3_bigint domain', () => { + const storage = types.Bigint('n') + const ord = types.BigintOrd('n_ord') + + expect(isEqlV3Column(storage)).toBe(true) + expect(getEqlV3Column('n', storage)?.getEqlType()).toBe( + 'public.eql_v3_bigint', + ) + expect(getEqlV3Column('n_ord', ord)?.getEqlType()).toBe( + 'public.eql_v3_bigint_ord', + ) + }) + + it('emits the concrete public.eql_v3_bigint* SQL type through pgTable', () => { + expect(accounts.balance.getSQLType()).toBe('public.eql_v3_bigint_ord') + expect(accounts.ledgerId.getSQLType()).toBe('public.eql_v3_bigint_eq') + expect(accounts.archived.getSQLType()).toBe('public.eql_v3_bigint') + }) + + it('encrypts a native bigint operand for eq without JSON-stringifying it', async () => { + const { ops, encryptQuery, render } = setup() + // A value beyond Number.MAX_SAFE_INTEGER to prove the bigint is passed + // through untouched (a JSON.stringify of a bigint would have thrown). + const value = 9223372036854775807n + const q = render(await ops.eq(accounts.ledgerId, value)) + + expect(q.sql).toContain( + 'eql_v3.eq("accounts"."ledger_id", $1::eql_v3.query_bigint_eq)', + ) + expect(q.params).toEqual([TERM_JSON]) + expect(encryptQuery.mock.calls[0]?.[0]).toBe(value) + }) + + it('emits ordering and range operators for a bigint_ord column', async () => { + const { ops, render } = setup() + + const gt = render(await ops.gt(accounts.balance, 10n)) + expect(gt.sql).toContain( + 'eql_v3.gt("accounts"."balance", $1::eql_v3.query_bigint_ord)', + ) + + const between = render(await ops.between(accounts.balance, -5n, 5n)) + expect(between.sql).toContain( + 'eql_v3.gte("accounts"."balance", $1::eql_v3.query_bigint_ord)', + ) + expect(between.sql).toContain( + 'eql_v3.lte("accounts"."balance", $2::eql_v3.query_bigint_ord)', + ) + + const asc = render(ops.asc(accounts.balance)) + expect(asc.sql).toContain('eql_v3.ord_term("accounts"."balance")') + }) + + it('rejects equality/ordering on a storage-only bigint column', async () => { + const { ops } = setup() + await expect(ops.eq(accounts.archived, 1n)).rejects.toBeInstanceOf( + EncryptionOperatorError, + ) + expect(() => ops.asc(accounts.archived)).toThrow(EncryptionOperatorError) + }) + + it('rejects a bare SQL expression that is not an encrypted column', async () => { + const { ops } = setup() + await expect(ops.eq(sql`1`, 1n)).rejects.toBeInstanceOf( + EncryptionOperatorError, + ) + }) +}) diff --git a/packages/stack-drizzle/__tests__/v3/codec.test.ts b/packages/stack-drizzle/__tests__/v3/codec.test.ts new file mode 100644 index 000000000..3049c2c2a --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/codec.test.ts @@ -0,0 +1,139 @@ +import { describe, expect, it } from 'vitest' +import { EqlV3CodecError, v3FromDriver, v3ToDriver } from '../../src/v3/codec' + +// A realistic `public.eql_v3_text_eq` envelope: schema version, table/column +// identifier, mp_base85 ciphertext, HMAC term. The trivial `{v:1,c:'ct'}` +// fixture this replaced could not distinguish an envelope from a bare object. +const ENVELOPE = { + v: 3, + i: { t: 'users', c: 'email' }, + c: 'mBbKmbNmNhX@Vv0N%1jQvA', + hm: '3a1f9c0e5b7d2a48e6c1f0b93d7a2e58c4b6f19d0e3a7c25b8f14d69a0c3e7b2', +} as const + +// SteVec documents carry the root ciphertext at `sv[0].c` and have no top-level +// `c` — the envelope guard must accept them. +const STE_VEC_ENVELOPE = { + v: 3, + k: 'sv', + i: { t: 'users', c: 'profile' }, + sv: [{ c: 'mBbKciphertext', s: 'selector', b: 'term' }], +} as const + +describe('v3 codec', () => { + it('serialises an envelope to a jsonb string', () => { + expect(v3ToDriver(ENVELOPE as never)).toBe(JSON.stringify(ENVELOPE)) + }) + + it('maps null/undefined to SQL NULL (JS null), never the JSON null literal', () => { + expect(v3ToDriver(null)).toBeNull() + expect(v3ToDriver(undefined)).toBeNull() + }) + + it('round-trips a realistic envelope through both directions', () => { + const serialised = v3ToDriver(ENVELOPE as never) + expect(v3FromDriver(serialised)).toEqual(ENVELOPE) + }) + + it('round-trips unicode and a long ciphertext', () => { + const envelope = { + ...ENVELOPE, + i: { t: 'users', c: 'café_☕' }, + c: 'z'.repeat(8192), + } + expect(v3FromDriver(v3ToDriver(envelope as never))).toEqual(envelope) + }) + + it('passes an already-parsed envelope through unchanged', () => { + expect(v3FromDriver(ENVELOPE as never)).toBe(ENVELOPE) + }) + + it('accepts a SteVec document, whose ciphertext lives at sv[0].c', () => { + expect(v3FromDriver(STE_VEC_ENVELOPE as never)).toBe(STE_VEC_ENVELOPE) + expect(v3FromDriver(JSON.stringify(STE_VEC_ENVELOPE))).toEqual( + STE_VEC_ENVELOPE, + ) + }) + + // `sv: []` has no `sv[0]`, so the guard's premise — a ciphertext at the + // decryption root — does not hold. Presence of the key is not enough. + it.each([ + ['an empty SteVec', { v: 3, k: 'sv', sv: [] }], + ['a non-array SteVec', { v: 3, k: 'sv', sv: {} }], + ['a null SteVec with no c', { v: 3, k: 'sv', sv: null }], + ])('rejects %s', (_label, envelope) => { + expect(() => v3FromDriver(envelope as never)).toThrow(EqlV3CodecError) + expect(() => v3FromDriver(envelope as never)).toThrow(/ciphertext/) + }) + + it('still accepts a scalar envelope, which has c and no sv', () => { + expect(v3FromDriver(ENVELOPE as never)).toBe(ENVELOPE) + }) + + it('normalises null/undefined to SQL NULL (JS null) on read', () => { + expect(v3FromDriver(null)).toBeNull() + expect(v3FromDriver(undefined)).toBeNull() + }) + + it('does not throw on a stray bigint in the envelope (defensive)', () => { + expect(v3ToDriver({ ...ENVELOPE, v: 3n } as never)).toContain('"v":"3"') + }) + + // Before these, a malformed string surfaced a raw SyntaxError and a + // wrong-shape payload was returned as-is — `v3FromDriver('5')` yielded `5` + // typed as an envelope, which then reached `decrypt` as garbage. + describe('malformed and non-envelope payloads', () => { + it.each([ + '{bad', + '', + '{"v":3,', + ])('throws EqlV3CodecError on unparseable jsonb %j', (raw) => { + expect(() => v3FromDriver(raw)).toThrow(EqlV3CodecError) + expect(() => v3FromDriver(raw)).toThrow(/Failed to parse/) + }) + + // The parse failure is the only codec path with an upstream error to + // preserve. Flattening it to a message string discards the SyntaxError and + // its stack, so a caller debugging a corrupt column loses where parsing + // actually broke. + it.each([ + '{bad', + '', + '{"v":3,', + ])('preserves the underlying SyntaxError as `cause` for %j', (raw) => { + let thrown: unknown + try { + v3FromDriver(raw) + } catch (error) { + thrown = error + } + + expect(thrown).toBeInstanceOf(EqlV3CodecError) + expect((thrown as EqlV3CodecError).cause).toBeInstanceOf(SyntaxError) + }) + + it.each([ + '5', + '"a string"', + 'true', + '[]', + '[{"v":3,"c":"ct"}]', + ])('throws on valid JSON %j that is not an envelope', (raw) => { + expect(() => v3FromDriver(raw)).toThrow(EqlV3CodecError) + }) + + it('throws on an object missing the schema version', () => { + expect(() => v3FromDriver({ c: 'ct' })).toThrow(/missing "v"/) + }) + + it('throws on an object carrying no ciphertext', () => { + expect(() => v3FromDriver({ v: 3, i: { t: 'u', c: 'e' } })).toThrow( + /missing a ciphertext/, + ) + }) + + it('throws on an array', () => { + expect(() => v3FromDriver([ENVELOPE] as never)).toThrow(/got an array/) + }) + }) +}) diff --git a/packages/stack-drizzle/__tests__/v3/column.test.ts b/packages/stack-drizzle/__tests__/v3/column.test.ts new file mode 100644 index 000000000..f812a3bcf --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/column.test.ts @@ -0,0 +1,179 @@ +import { types as v3Types } from '@cipherstash/stack/eql/v3' +import { + EQL_V3_DOMAIN_SCHEMA, + eqlTypeSlug as slug, + typedEntries, + V3_MATRIX, +} from '@cipherstash/test-kit/catalog' +import { pgTable } from 'drizzle-orm/pg-core' +import { describe, expect, it } from 'vitest' +import { + EQL_V3_DOMAINS, + getEqlV3Column, + isEqlV3Column, + makeEqlV3Column, +} from '../../src/v3/column' + +describe('makeEqlV3Column', () => { + it('sets dataType() to the concrete eql_v3 domain', () => { + const col = makeEqlV3Column(v3Types.IntegerOrd('age')) + const table = pgTable('users', { age: col }) + + expect(table.age.getSQLType()).toBe('public.eql_v3_integer_ord') + }) + + it('recovers the stashed builder before and after pgTable processing', () => { + const col = makeEqlV3Column(v3Types.TextEq('nickname')) + expect(isEqlV3Column(col)).toBe(true) + expect(getEqlV3Column('nickname', col)?.getEqlType()).toBe( + 'public.eql_v3_text_eq', + ) + + const t = pgTable('users', { nickname: col }) + expect(getEqlV3Column('nickname', t.nickname)?.getEqlType()).toBe( + 'public.eql_v3_text_eq', + ) + }) + + it('stashes the builder under a single symbol key, with no string twin', () => { + const symbol = Symbol.for('cipherstash:eqlv3Column') + const carrierOf = (column: unknown) => + (column as { config?: { customTypeParams?: Record } }) + .config?.customTypeParams + + const col = makeEqlV3Column(v3Types.TextEq('nickname')) + const table = pgTable('users', { nickname: col }) + + // `pgTable` builds a NEW PgColumn that does not carry the symbol directly — + // it reaches the builder only through the shared `config.customTypeParams`. + // That is the carrier the operators actually resolve through, so assert on + // it specifically rather than on "some carrier somewhere". + const pgCarrier = carrierOf(table.nickname) + expect(pgCarrier).toBeDefined() + expect(symbol in (pgCarrier as object)).toBe(true) + expect(getEqlV3Column('nickname', table.nickname)?.getEqlType()).toBe( + 'public.eql_v3_text_eq', + ) + + // ...and no carrier keeps a redundant string twin of the symbol key. + for (const carrier of [col, carrierOf(col), table.nickname]) { + expect(carrier).toBeDefined() + expect('_eqlv3Column' in (carrier as object)).toBe(false) + } + }) + + it('every matrix domain slugs to a bare, dot-free column identifier', () => { + // Guards the shared slug against drifting from the real domain schema: if + // the domains move, the prefix constant must move with them or the slug + // silently leaks a qualified name into the generated DDL. + for (const [eqlType] of typedEntries(V3_MATRIX)) { + expect(eqlType.startsWith(`${EQL_V3_DOMAIN_SCHEMA}.`)).toBe(true) + expect(slug(eqlType)).not.toContain('.') + } + }) + + it('EQL_V3_DOMAINS contains every concrete domain', () => { + const all = Object.values(v3Types).map((f) => f('x').getEqlType()) + for (const domain of all) expect(EQL_V3_DOMAINS.has(domain)).toBe(true) + }) + + it('isEqlV3Column is false for a plain value', () => { + expect(isEqlV3Column({})).toBe(false) + }) + + it('recognises v3 columns by the Drizzle getSQLType API', () => { + expect( + isEqlV3Column({ + getSQLType: () => 'public.eql_v3_text_eq', + }), + ).toBe(true) + }) + + it('recovers a v3 builder for columns recognised by getSQLType', () => { + const builder = getEqlV3Column('nickname', { + getSQLType: () => 'public.eql_v3_text_eq', + }) + + expect(builder?.getName()).toBe('nickname') + expect(builder?.getEqlType()).toBe('public.eql_v3_text_eq') + }) + + it('recognises v3 columns by dataType() when getSQLType is absent', () => { + const column = { dataType: () => 'public.eql_v3_text_eq' } + const builder = getEqlV3Column('nickname', column) + + expect(isEqlV3Column(column)).toBe(true) + expect(builder?.getName()).toBe('nickname') + expect(builder?.getEqlType()).toBe('public.eql_v3_text_eq') + }) + + it('recognises v3 columns by sqlName when getSQLType is absent', () => { + const column = { sqlName: 'public.eql_v3_integer_ord' } + const builder = getEqlV3Column('age', column) + + expect(isEqlV3Column(column)).toBe(true) + expect(builder?.getName()).toBe('age') + expect(builder?.getEqlType()).toBe('public.eql_v3_integer_ord') + }) + + it.each( + typedEntries(V3_MATRIX), + )('%s round-trips through makeEqlV3Column and pgTable', (eqlType, spec) => { + const columnName = slug(eqlType) + const builder = spec.builder(columnName) + const column = makeEqlV3Column(builder) + + expect(builder.getEqlType()).toBe(eqlType) + expect(builder).toBeInstanceOf(spec.ColumnClass) + expect(isEqlV3Column(column)).toBe(true) + expect(getEqlV3Column(columnName, column)?.getEqlType()).toBe(eqlType) + + const table = pgTable('users', { [columnName]: column } as never) + const pgColumn = (table as Record)[ + columnName + ] + expect(pgColumn?.getSQLType()).toBe(eqlType) + expect(getEqlV3Column(columnName, pgColumn)?.getEqlType()).toBe(eqlType) + }) + + // The `toDriver`/`fromDriver` closures wired into `customType` (column.ts) are + // otherwise only tested via the standalone codec functions, so the wiring + // itself — including the SQL-NULL safety net — was never exercised. + describe('codec wiring on the built column', () => { + type Mapper = { + mapToDriverValue(value: unknown): unknown + mapFromDriverValue(value: unknown): unknown + } + const mapperFor = (name: string): Mapper => { + const table = pgTable('users', { + [name]: makeEqlV3Column(v3Types.TextEq(name)), + } as never) + return (table as unknown as Record)[name] + } + + const ENVELOPE = { + v: 3, + i: { t: 'users', c: 'nickname' }, + c: 'mBbKciphertext', + hm: 'hmac', + } + + it('serialises an envelope on write and parses it back on read', () => { + const column = mapperFor('nickname') + const driverValue = column.mapToDriverValue(ENVELOPE) + + expect(driverValue).toBe(JSON.stringify(ENVELOPE)) + expect(column.mapFromDriverValue(driverValue)).toEqual(ENVELOPE) + }) + + it('maps a null envelope to SQL NULL on write', () => { + expect(mapperFor('nickname').mapToDriverValue(null)).toBeNull() + }) + + it('rejects a non-envelope driver value rather than passing it through', () => { + expect(() => mapperFor('nickname').mapFromDriverValue('5')).toThrow( + /EQL encrypted envelope/, + ) + }) + }) +}) diff --git a/packages/stack-drizzle/__tests__/v3/exports.test.ts b/packages/stack-drizzle/__tests__/v3/exports.test.ts new file mode 100644 index 000000000..4ad6d98e3 --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/exports.test.ts @@ -0,0 +1,40 @@ +import { describe, expect, it } from 'vitest' +import * as barrel from '../../src/v3/index.js' + +// Exhaustive, so ADDING an export fails here too. The previous version asserted +// only four names, leaving the codec/column re-exports unpinned and letting a +// new export slip into the public surface unnoticed. +const PUBLIC_SURFACE = [ + 'EncryptionOperatorError', + 'EqlV3CodecError', + 'createEncryptionOperatorsV3', + 'extractEncryptionSchemaV3', + 'getEqlV3Column', + 'isEqlV3Column', + 'makeEqlV3Column', + 'types', + 'v3FromDriver', + 'v3ToDriver', +] as const + +describe('v3 drizzle barrel', () => { + it('exports exactly the public surface', () => { + expect(Object.keys(barrel).sort()).toEqual([...PUBLIC_SURFACE]) + }) + + // The key check above sees names, not values: a re-export that resolves to + // `undefined` still lists its key. Sweep every export the barrel claims. + it('exports every name as a callable, and types as a namespace', () => { + const callables = Object.entries(barrel).filter( + ([name]) => name !== 'types', + ) + expect(callables).toHaveLength(PUBLIC_SURFACE.length - 1) + + for (const [name, value] of callables) { + expect(typeof value, name).toBe('function') + } + + expect(typeof barrel.types.TextSearch).toBe('function') + expect(barrel.types.IntegerOrd('age')).toBeDefined() + }) +}) diff --git a/packages/stack-drizzle/__tests__/v3/operators.test-d.ts b/packages/stack-drizzle/__tests__/v3/operators.test-d.ts new file mode 100644 index 000000000..c2c09c1d6 --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/operators.test-d.ts @@ -0,0 +1,75 @@ +import type { Result } from '@byteslice/result' +import type { AuditConfig } from '@cipherstash/stack/adapter-kit' +import type { EncryptionClient } from '@cipherstash/stack/encryption' +import type { EncryptionError } from '@cipherstash/stack/errors' +import type { LockContext } from '@cipherstash/stack/identity' +import type { EncryptedQueryResult } from '@cipherstash/stack/types' +import type { EncryptionV3 } from '@cipherstash/stack/v3' +import { describe, expectTypeOf, it } from 'vitest' +import { createEncryptionOperatorsV3 } from '../../src/v3/index.js' + +/** + * Static regression guard for M1: `createEncryptionOperatorsV3` must accept the + * `TypedEncryptionClient` that `EncryptionV3` resolves to — the documented + * `createEncryptionOperatorsV3(await EncryptionV3({ schemas }))` usage — as well + * as the nominal `EncryptionClient` and a hand-rolled `{ encryptQuery }` double, + * none requiring a cast. Typing the parameter to `EncryptionClient` (the + * original bug) makes the first call below a compile error, which this suite + * would then catch. Every operand is now encrypted with `encryptQuery` (#622), + * so the operand client contract is `encryptQuery` in both its single and batch + * forms; the doubles model that. Lives in a `*.test-d.ts` so it is inside the + * existing typecheck scope without dragging the loose-typed runtime suites in. + */ +describe('createEncryptionOperatorsV3 - client parameter (M1)', () => { + type V3Client = Awaited> + + // A query operation resolving `Result` — the surface the factory drives. + type QueryOp = { + withLockContext(lc: LockContext): QueryOp + audit(cfg: AuditConfig): QueryOp + then: PromiseLike>['then'] + } + + it('accepts the client EncryptionV3 returns with no cast', () => { + expectTypeOf(createEncryptionOperatorsV3).toBeCallableWith({} as V3Client) + }) + + it('still accepts the nominal EncryptionClient', () => { + expectTypeOf(createEncryptionOperatorsV3).toBeCallableWith( + {} as EncryptionClient, + ) + }) + + it('accepts a minimal structural { encryptQuery } double', () => { + // The double models what the real client returns for both encryptQuery forms: + // an operation whose `then` resolves `Result` (single) + // or `Result` (batch), not `unknown`. That is the + // point of the un-erasure — the factory reads `result.data` as a query term + // (single) or an array of them (batch) rather than casting it. The single + // implementation returns the intersection, so it satisfies both overloads. + const double = { + encryptQuery: ( + _valueOrTerms: never, + _opts?: never, + ): QueryOp & QueryOp => + ({}) as never, + } + expectTypeOf(createEncryptionOperatorsV3).toBeCallableWith(double) + }) + + it('rejects an { encryptQuery } double that resolves `unknown` (the erasure regression)', () => { + // The complement of the test above, and the one with teeth: `toBeCallableWith` + // a correctly-typed double keeps passing even if the client contract + // regressed to `unknown` (a correct value is assignable to `unknown`), so it + // cannot catch re-erasure. This can. `encryptQuery` resolving `unknown` must + // NOT satisfy the factory, whose contract resolves an `EncryptedQueryResult`; + // if the erasure ever comes back, the `@ts-expect-error` goes unused and fails. + const erased = { + encryptQuery: (_valueOrTerms: never, _opts?: never): QueryOp => + ({}) as never, + } + // @ts-expect-error — `encryptQuery` resolving `unknown` does not satisfy the + // factory's `ChainableOperation` client contract. + createEncryptionOperatorsV3(erased) + }) +}) diff --git a/packages/stack-drizzle/__tests__/v3/operators.test.ts b/packages/stack-drizzle/__tests__/v3/operators.test.ts new file mode 100644 index 000000000..95a2f8053 --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/operators.test.ts @@ -0,0 +1,782 @@ +import { needleFor } from '@cipherstash/test-kit' +import { + eqlTypeSlug as slug, + typedEntries, + V3_MATRIX, +} from '@cipherstash/test-kit/catalog' +import { + eq as drizzleEq, + exists, + isNotNull, + isNull, + not, + notExists, + type SQL, + type SQLWrapper, + sql, +} from 'drizzle-orm' +import { integer, PgDialect, pgTable } from 'drizzle-orm/pg-core' +import { describe, expect, it, vi } from 'vitest' +import { makeEqlV3Column } from '../../src/v3/column' +import { + createEncryptionOperatorsV3, + EncryptionOperatorError, +} from '../../src/v3/operators' +import { extractEncryptionSchemaV3 } from '../../src/v3/schema-extraction' +import { types } from '../../src/v3/types' + +// A query TERM (from `encryptQuery`), not a storage envelope: it carries index +// terms but NO ciphertext `c` — that is the whole point of the encrypt → +// encryptQuery move. The operator layer casts it to the column's query domain. +const TERM = { hm: 'h', v: 3 } +const TERM_JSON = JSON.stringify(TERM) +const lockContext = { identityClaim: 'user-123' } +const audit = { metadata: { actor: 'test' } } + +// The `eql_v3.query_` type an operand for a matrix column casts to. +// `slug('public.eql_v3_text_eq')` → `eql_v3_text_eq`; stripping the `eql_v3_` +// prefix yields the domain suffix the query type is named for (`text_eq` → +// `eql_v3.query_text_eq`). +const qcast = (eqlType: string): string => + `eql_v3.query_${slug(eqlType).replace(/^eql_v3_/, '')}` + +type TermResult = { data: unknown } | { failure: { message: string } } + +function chainable(result: Promise) { + const op = result as Promise & { + withLockContext: ReturnType + audit: ReturnType + } + op.withLockContext = vi.fn(() => op) + op.audit = vi.fn(() => op) + return op +} + +// The double now models `encryptQuery` in BOTH its forms: the single +// `(value, opts)` form used by scalar/JSON operands, and the batch `(terms[])` +// form used by inArray/notInArray. `termImpl` maps a plaintext value to the +// query term the crossing would return (defaulting to a constant `TERM`); the +// batch form applies it position-for-position so callers can pin ordering. +function setup(termImpl: (value?: unknown) => unknown = () => TERM) { + const encryptQuery = vi.fn((valueOrTerms: unknown, opts?: unknown) => { + // Route exactly as the real client does (packages/stack/src/encryption/ + // index.ts): batch ONLY when no opts are supplied AND the arg is a term + // array. An array-valued single query WITH opts (e.g. a searchableJson + // array needle) must take the single path here too, or the double would + // diverge from production for that shape. + if (opts === undefined && Array.isArray(valueOrTerms)) { + const terms = valueOrTerms as Array<{ value: unknown }> + return chainable( + Promise.resolve({ data: terms.map((t) => termImpl(t.value)) }), + ) + } + return chainable(Promise.resolve({ data: termImpl(valueOrTerms) })) + }) + // The factory's `client` parameter is the structural `{ encryptQuery }` + // surface, so this hand-rolled double satisfies it with no cast. + const client = { encryptQuery } + const ops = createEncryptionOperatorsV3(client, { lockContext, audit }) + const dialect = new PgDialect() + const render = (s: unknown) => dialect.sqlToQuery(s as SQL) + return { ops, encryptQuery, render } +} + +const matrixEntries = typedEntries(V3_MATRIX) +const matrixTable = pgTable( + 'matrix_users', + Object.fromEntries( + matrixEntries.map(([eqlType, spec]) => [ + slug(eqlType), + makeEqlV3Column(spec.builder(slug(eqlType))), + ]), + ) as never, +) +const matrixColumn = (eqlType: string) => + (matrixTable as Record)[slug(eqlType)] +const sampleFor = (spec: (typeof V3_MATRIX)[keyof typeof V3_MATRIX]) => + spec.samples[0] + +const equalityDomains = matrixEntries.filter( + ([, spec]) => spec.indexes.unique || spec.indexes.ore || spec.indexes.ope, +) +const orderDomains = matrixEntries.filter( + ([, spec]) => spec.indexes.ore || spec.indexes.ope, +) +const matchDomains = matrixEntries.filter(([, spec]) => spec.indexes.match) +// Domains with NO scalar query index (unique/ore/ope/match), so `eq`/`ne`/ +// ordering all throw. This is the truly storage-only scalar domains PLUS +// `eql_v3_json` — json is a QUERYABLE domain (containment), it just answers no +// scalar op, so it lands here for the eq/order rejection checks. +const nonScalarQueryDomains = matrixEntries.filter( + ([, spec]) => + !spec.indexes.unique && + !spec.indexes.ore && + !spec.indexes.ope && + !spec.indexes.match, +) +// Of those, the ones that also reject `contains` — i.e. everything except json. +// json answers `contains` via `@>`, so it is excluded here and gets its own +// positive assertion in the JSON containment describe above. +const noContainmentDomains = nonScalarQueryDomains.filter( + ([, spec]) => !spec.indexes.ste_vec, +) + +const users = pgTable('users', { + id: integer().primaryKey(), + email: types.TextSearch('email'), + nickname: types.TextEq('nickname'), + textMatch: types.TextMatch('text_match'), + textOrd: types.TextOrd('text_ord'), + textOrdOre: types.TextOrdOre('text_ord_ore'), + int2Age: types.SmallintOrd('int2_age'), + age: types.IntegerOrd('age'), + createdOn: types.DateOrd('created_on'), + createdAt: types.TimestampOrd('created_at'), + amount: types.NumericOrd('amount'), + score4: types.RealOrd('score4'), + score8: types.DoubleOrd('score8'), + flag: types.Boolean('flag'), +}) + +describe('createEncryptionOperatorsV3 - equality', () => { + it.each( + equalityDomains, + )('%s eq emits the latest two-arg eql_v3.eq with a query-term operand', async (eqlType, spec) => { + const { ops, encryptQuery, render } = setup() + const q = render(await ops.eq(matrixColumn(eqlType), sampleFor(spec))) + + expect(q.sql).toContain( + `eql_v3.eq("matrix_users"."${slug(eqlType)}", $1::${qcast(eqlType)})`, + ) + expect(q.params).toEqual([TERM_JSON]) + expect(encryptQuery.mock.calls[0]?.[1]?.column.getName()).toBe( + slug(eqlType), + ) + expect(encryptQuery.mock.calls[0]?.[1]?.queryType).toBe('equality') + }) + + it.each(equalityDomains)('%s ne emits eql_v3.neq', async (eqlType, spec) => { + const { ops, encryptQuery, render } = setup() + const q = render(await ops.ne(matrixColumn(eqlType), sampleFor(spec))) + + expect(q.sql).toContain( + `eql_v3.neq("matrix_users"."${slug(eqlType)}", $1::${qcast(eqlType)})`, + ) + expect(q.params).toEqual([TERM_JSON]) + expect(encryptQuery.mock.calls[0]?.[1]?.column.getName()).toBe( + slug(eqlType), + ) + expect(encryptQuery.mock.calls[0]?.[1]?.queryType).toBe('equality') + }) + + it('same-named columns on different tables use their own equality capability', async () => { + const accounts = pgTable('accounts', { + email: types.TextEq('email'), + }) + pgTable('metrics', { + email: types.IntegerOrd('email'), + }) + const { ops, render } = setup() + + const q = render(await ops.eq(accounts.email, 'ada@example.com')) + + expect(q.sql).toContain( + 'eql_v3.eq("accounts"."email", $1::eql_v3.query_text_eq)', + ) + }) + + it('does not reuse a cached extracted schema across distinct pgTable objects with the same SQL name', async () => { + const first = pgTable('shared', { + email: types.TextEq('email'), + }) + const second = pgTable('shared', { + age: types.IntegerOrd('age'), + }) + const { ops, encryptQuery } = setup() + + await ops.eq(first.email, 'ada@example.com') + await ops.eq(second.age, 37) + + expect(encryptQuery.mock.calls[1]?.[1]?.table.build()).toEqual( + extractEncryptionSchemaV3(second).build(), + ) + }) + + it('passes default lock context and audit to operand encryption', async () => { + const { ops, encryptQuery } = setup() + await ops.eq(users.nickname, 'ada') + const op = encryptQuery.mock.results[0]?.value + expect(op.withLockContext).toHaveBeenCalledWith(lockContext) + expect(op.audit).toHaveBeenCalledWith(audit) + }) + + it('per-call lock context and audit override constructor defaults', async () => { + const { ops, encryptQuery } = setup() + const callLockContext = { identityClaim: 'user-456' } + const callAudit = { metadata: { actor: 'override' } } + + await ops.eq(users.nickname, 'ada', { + lockContext: callLockContext, + audit: callAudit, + }) + + const op = encryptQuery.mock.results[0]?.value + expect(op.withLockContext).toHaveBeenCalledWith(callLockContext) + expect(op.withLockContext).not.toHaveBeenCalledWith(lockContext) + expect(op.audit).toHaveBeenCalledWith(callAudit) + expect(op.audit).not.toHaveBeenCalledWith(audit) + }) +}) + +describe('createEncryptionOperatorsV3 - comparison & range', () => { + it.each([ + ['gt', 'eql_v3.gt'], + ['gte', 'eql_v3.gte'], + ['lt', 'eql_v3.lt'], + ['lte', 'eql_v3.lte'], + ] as const)('%s emits %s for every ORE domain', async (op, fn) => { + for (const [eqlType, spec] of orderDomains) { + const { ops, encryptQuery, render } = setup() + const q = render(await ops[op](matrixColumn(eqlType), sampleFor(spec))) + + expect(q.sql).toContain( + `${fn}("matrix_users"."${slug(eqlType)}", $1::${qcast(eqlType)})`, + ) + expect(q.params).toEqual([TERM_JSON]) + expect(encryptQuery.mock.calls[0]?.[1]?.column.getName()).toBe( + slug(eqlType), + ) + expect(encryptQuery.mock.calls[0]?.[1]?.queryType).toBe('orderAndRange') + } + }) + + it.each( + orderDomains, + )('%s between emits a bounded range with two query-term operands', async (eqlType, spec) => { + const { ops, render } = setup() + const value = sampleFor(spec) + const q = render(await ops.between(matrixColumn(eqlType), value, value)) + + expect(q.sql).toContain( + `eql_v3.gte("matrix_users"."${slug(eqlType)}", $1::${qcast(eqlType)})`, + ) + expect(q.sql).toContain( + `eql_v3.lte("matrix_users"."${slug(eqlType)}", $2::${qcast(eqlType)})`, + ) + expect(q.params).toEqual([TERM_JSON, TERM_JSON]) + }) + + it.each( + orderDomains, + )('%s notBetween wraps the range in NOT (...)', async (eqlType, spec) => { + const { ops, render } = setup() + const value = sampleFor(spec) + const q = render(await ops.notBetween(matrixColumn(eqlType), value, value)) + + expect(q.sql).toMatch(/^not \(/i) + expect(q.sql).toContain( + `eql_v3.gte("matrix_users"."${slug(eqlType)}", $1::${qcast(eqlType)})`, + ) + expect(q.sql).toContain( + `eql_v3.lte("matrix_users"."${slug(eqlType)}", $2::${qcast(eqlType)})`, + ) + expect(q.params).toEqual([TERM_JSON, TERM_JSON]) + }) + + // Every other `between` case passes identical bounds against a constant + // encrypt stub, so the operand never reaches an assertion and a min/max + // transposition inside `range` is invisible. Echo the plaintext through the + // stub instead, and pin that `gte` binds `min` and `lte` binds `max`. + it('between binds min to gte and max to lte, in that order', async () => { + const { ops, render } = setup((value) => ({ p: value })) + + const q = render(await ops.between(users.age, -128, 127)) + + expect(q.sql).toBe( + '(eql_v3.gte("users"."age", $1::eql_v3.query_integer_ord) AND eql_v3.lte("users"."age", $2::eql_v3.query_integer_ord))', + ) + expect(q.params).toEqual(['{"p":-128}', '{"p":127}']) + }) + + it('notBetween binds min to gte and max to lte, in that order', async () => { + const { ops, render } = setup((value) => ({ p: value })) + + const q = render(await ops.notBetween(users.age, -128, 127)) + + expect(q.params).toEqual(['{"p":-128}', '{"p":127}']) + }) + + it('not(between(...)) negates the whole range, not just its lower bound', async () => { + const { ops, render } = setup() + + const q = render(ops.not(await ops.between(users.age, 25, 40))) + + // `not eql_v3.gte(..) AND eql_v3.lte(..)` would parse as `(NOT gte) AND + // lte` in Postgres — every row under the lower bound, none of the intended + // complement. The range must arrive pre-parenthesised. + expect(q.sql).toBe( + 'not (eql_v3.gte("users"."age", $1::eql_v3.query_integer_ord) AND eql_v3.lte("users"."age", $2::eql_v3.query_integer_ord))', + ) + }) + + it('between stays parenthesised when combined with other predicates', async () => { + const { ops, render } = setup() + + const q = render( + await ops.or( + ops.between(users.age, 25, 40), + ops.eq(users.nickname, 'ada'), + ), + ) + + expect(q.sql).toContain( + '(eql_v3.gte("users"."age", $1::eql_v3.query_integer_ord) AND eql_v3.lte("users"."age", $2::eql_v3.query_integer_ord))', + ) + }) + + it.each( + orderDomains, + )('%s asc / desc extract the ord term', (eqlType, spec) => { + const { ops, render } = setup() + // eql-3.0.0 splits the extractor by ordering flavour: `ord_term` for the + // OPE-backed `_ord` domains, `ord_term_ore` for the block-ORE `_ord_ore`. + const fn = spec.indexes.ore ? 'ord_term_ore' : 'ord_term' + const ascq = render(ops.asc(matrixColumn(eqlType))) + expect(ascq.sql).toContain( + `eql_v3.${fn}("matrix_users"."${slug(eqlType)}")`, + ) + expect(ascq.sql.toLowerCase()).toContain('asc') + + const descq = render(ops.desc(matrixColumn(eqlType))) + expect(descq.sql).toContain( + `eql_v3.${fn}("matrix_users"."${slug(eqlType)}")`, + ) + expect(descq.sql.toLowerCase()).toContain('desc') + }) +}) + +describe('createEncryptionOperatorsV3 - free-text match', () => { + it.each( + matchDomains, + )('%s matches emits latest eql_v3.contains with a query-term operand', async (eqlType, spec) => { + const { ops, encryptQuery, render } = setup() + const q = render(await ops.matches(matrixColumn(eqlType), needleFor(spec))) + + expect(q.sql).toContain( + `eql_v3.contains("matrix_users"."${slug(eqlType)}", $1::${qcast(eqlType)})`, + ) + expect(q.params).toEqual([TERM_JSON]) + expect(encryptQuery.mock.calls[0]?.[1]?.column.getName()).toBe( + slug(eqlType), + ) + expect(encryptQuery.mock.calls[0]?.[1]?.queryType).toBe('freeTextSearch') + }) + + // A needle shorter than the tokenizer's `token_length` produces an empty + // bloom filter, and `stored_bf @> '{}'` is true for every row — so this must + // throw rather than silently return the whole table. + it.each( + matchDomains, + )('%s matches rejects a needle shorter than token_length before encrypting', async (eqlType) => { + const { ops, encryptQuery } = setup() + await expect(ops.matches(matrixColumn(eqlType), 'ad')).rejects.toThrow( + /at least 3 characters/, + ) + await expect(ops.matches(matrixColumn(eqlType), '')).rejects.toThrow( + EncryptionOperatorError, + ) + expect(encryptQuery).not.toHaveBeenCalled() + }) + + it('matches accepts a needle exactly at token_length', async () => { + const { ops, render } = setup() + const q = render(await ops.matches(users.email, 'ada')) + expect(q.sql).toContain( + 'eql_v3.contains("users"."email", $1::eql_v3.query_text_search)', + ) + }) + + it('negation is expressed through the passthrough Drizzle not operator', async () => { + const { ops, render } = setup() + const q = render(ops.not(await ops.matches(users.email, 'example.com'))) + expect(q.sql).toMatch(/^not /i) + expect(q.sql).toContain( + 'eql_v3.contains("users"."email", $1::eql_v3.query_text_search)', + ) + }) + + it('does not expose obsolete like/ilike helpers', () => { + const { ops } = setup() + expect('like' in ops).toBe(false) + expect('ilike' in ops).toBe(false) + expect('notIlike' in ops).toBe(false) + }) +}) + +describe('createEncryptionOperatorsV3 - JSON containment', () => { + const JSON_TYPE = 'public.eql_v3_json' + + // json has no `eql_v3.contains` overload: containment is the `@>` operator, + // and the needle is a narrowed `query_jsonb` term from `encryptQuery` (no + // ciphertext), cast to `eql_v3.query_jsonb`. + it('contains emits the @> operator with a query_jsonb needle', async () => { + const { ops, encryptQuery, render } = setup() + const q = render( + await ops.contains(matrixColumn(JSON_TYPE), { roles: ['eng'] }), + ) + + expect(q.sql.toLowerCase()).toContain( + `"matrix_users"."${slug(JSON_TYPE)}" operator(public.@>) $1::eql_v3.query_jsonb`, + ) + expect(q.sql).not.toContain('eql_v3.contains') + // The needle is the encryptQuery result, not a full storage envelope. + expect(q.params).toEqual([TERM_JSON]) + expect(encryptQuery).toHaveBeenCalledTimes(1) + expect(encryptQuery.mock.calls[0]?.[0]).toEqual({ roles: ['eng'] }) + expect(encryptQuery.mock.calls[0]?.[1]).toMatchObject({ + queryType: 'searchableJson', + }) + }) + + it('JSON containment carries the default lock context and audit config', async () => { + const { ops, encryptQuery } = setup() + await ops.contains(matrixColumn(JSON_TYPE), { roles: ['eng'] }) + const op = encryptQuery.mock.results[0]?.value + expect(op.withLockContext).toHaveBeenCalledWith(lockContext) + expect(op.audit).toHaveBeenCalledWith(audit) + }) + + it('contains surfaces an encryptQuery failure as an EncryptionOperatorError', async () => { + const { ops, encryptQuery } = setup() + encryptQuery.mockReturnValueOnce( + chainable(Promise.resolve({ failure: { message: 'boom' } })), + ) + await expect( + ops.contains(matrixColumn(JSON_TYPE), { roles: ['eng'] }), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + }) + + it('contains rejects a null operand before calling encryptQuery', async () => { + const { ops, encryptQuery } = setup() + await expect( + ops.contains(matrixColumn(JSON_TYPE), null), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + expect(encryptQuery).not.toHaveBeenCalled() + }) + + // `doc @> '{}'` holds for every row (jsonb `{} ⊆ anything`); an empty-object + // needle would silently return the whole table, so it is refused before + // encrypting — the same whole-table guard the bloom path applies. + it('contains rejects an empty-object needle before calling encryptQuery', async () => { + const { ops, encryptQuery } = setup() + await expect(ops.contains(matrixColumn(JSON_TYPE), {})).rejects.toThrow( + /matches every row/, + ) + expect(encryptQuery).not.toHaveBeenCalled() + }) +}) + +describe('createEncryptionOperatorsV3 - domains with no scalar query', () => { + it.each(nonScalarQueryDomains)('%s eq throws', async (eqlType, spec) => { + const { ops } = setup() + await expect( + ops.eq(matrixColumn(eqlType), sampleFor(spec)), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + }) + + it.each(noContainmentDomains)('%s contains throws', async (eqlType, spec) => { + const { ops } = setup() + await expect( + ops.contains(matrixColumn(eqlType), sampleFor(spec)), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + }) + + it.each(nonScalarQueryDomains)('%s asc throws synchronously', (eqlType) => { + const { ops } = setup() + expect(() => ops.asc(matrixColumn(eqlType))).toThrow( + EncryptionOperatorError, + ) + }) +}) + +describe('createEncryptionOperatorsV3 - array, ordering, combinators', () => { + it('inArray ORs one eq term per value; empty array throws', async () => { + const { ops, render } = setup() + const q = render(await ops.inArray(users.nickname, ['ada', 'grace'])) + expect(q.sql).toContain(' or ') + expect((q.sql.match(/eql_v3\.eq/g) ?? []).length).toBe(2) + await expect(ops.inArray(users.nickname, [])).rejects.toThrow(/non-empty/) + }) + + it('inArray encrypts every value in one batch crossing, ORing one eq term each', async () => { + const { ops, encryptQuery, render } = setup() + const values = [ + 'ada', + 'grace', + 'alan', + 'katherine', + 'dorothy', + 'mary', + 'joan', + ] + + const q = render(await ops.inArray(users.nickname, values)) + + expect((q.sql.match(/eql_v3\.eq/g) ?? []).length).toBe(values.length) + expect(q.params).toEqual(values.map(() => TERM_JSON)) + // No fan-out anymore: the whole list crosses in a single batch call. + expect(encryptQuery).toHaveBeenCalledTimes(1) + const terms = encryptQuery.mock.calls[0]?.[0] as Array<{ + value: unknown + column: { getName(): string } + }> + expect(terms.map((c) => c.value)).toEqual(values) + expect(terms.every((c) => c.column.getName() === 'nickname')).toBe(true) + }) + + it('inArray on an ORE column uses ORE equality for each term', async () => { + const { ops, render } = setup() + const q = render(await ops.inArray(users.age, [30, 42])) + expect(q.sql).toContain(' or ') + expect((q.sql.match(/eql_v3\.eq/g) ?? []).length).toBe(2) + }) + + it('notInArray ANDs one ne term per value; empty array throws', async () => { + const { ops, render } = setup() + const q = render(await ops.notInArray(users.nickname, ['ada', 'grace'])) + expect(q.sql).toContain(' and ') + await expect(ops.notInArray(users.nickname, [])).rejects.toThrow( + /non-empty/, + ) + }) + + it('notInArray on an ORE column uses ORE inequality for each term', async () => { + const { ops, render } = setup() + const q = render(await ops.notInArray(users.age, [30, 42])) + expect(q.sql).toContain(' and ') + expect((q.sql.match(/eql_v3\.neq/g) ?? []).length).toBe(2) + }) + + it('inArray encrypts the whole list in a single encryptQuery batch crossing', async () => { + const { ops, encryptQuery, render } = setup() + const values = ['ada', 'grace', 'alan', 'katherine', 'dorothy'] + + const q = render(await ops.inArray(users.nickname, values)) + + expect(encryptQuery).toHaveBeenCalledTimes(1) + const terms = encryptQuery.mock.calls[0]?.[0] as Array<{ + value: unknown + column: { getName(): string } + }> + expect(terms.map((c) => c.value)).toEqual(values) + expect(terms.every((c) => c.column.getName() === 'nickname')).toBe(true) + expect((q.sql.match(/eql_v3\.eq/g) ?? []).length).toBe(values.length) + expect(q.params).toEqual(values.map(() => TERM_JSON)) + }) + + it('notInArray batch-encrypts once and ANDs one ne term per value', async () => { + const { ops, encryptQuery, render } = setup() + + const q = render(await ops.notInArray(users.nickname, ['ada', 'grace'])) + + expect(encryptQuery).toHaveBeenCalledTimes(1) + expect((q.sql.match(/eql_v3\.neq/g) ?? []).length).toBe(2) + expect(q.sql).toContain(' and ') + }) + + it('batch operand encryption carries the lock context and audit config', async () => { + const { ops, encryptQuery } = setup() + + await ops.inArray(users.nickname, ['ada', 'grace']) + + const op = encryptQuery.mock.results[0]?.value + expect(op.withLockContext).toHaveBeenCalledWith(lockContext) + expect(op.audit).toHaveBeenCalledWith(audit) + }) + + it('batch terms keep their positions so each eq term matches its value', async () => { + // Echo each value through the batch so a re-ordering inside `encryptOperands` + // would surface as a mismatched param, not be masked by a constant term. + const { ops, render } = setup((value) => ({ c: value })) + + const q = render(await ops.inArray(users.nickname, ['ada', 'grace'])) + + expect(q.params).toEqual([ + JSON.stringify({ c: 'ada' }), + JSON.stringify({ c: 'grace' }), + ]) + }) + + it('a batch encryption failure is wrapped with operator context', async () => { + const { ops, encryptQuery } = setup() + encryptQuery.mockReturnValueOnce( + chainable(Promise.resolve({ failure: { message: 'bad query term' } })), + ) + + await expect( + ops.inArray(users.nickname, ['ada', 'grace']), + ).rejects.toMatchObject({ + name: 'EncryptionOperatorError', + context: { columnName: 'nickname', operator: 'inArray' }, + }) + }) + + it('a null value in the list throws before any encryption crossing', async () => { + const { ops, encryptQuery } = setup() + + await expect(ops.inArray(users.nickname, ['ada', null])).rejects.toThrow( + /isNull/, + ) + expect(encryptQuery).not.toHaveBeenCalled() + }) + + it('a batch response of the wrong length is rejected rather than silently truncated', async () => { + const { ops, encryptQuery } = setup() + // One term for two values — the batch contract is violated. + encryptQuery.mockReturnValue(chainable(Promise.resolve({ data: [TERM] }))) + + // Pin the counts: an off-by-one guard, or a rejection thrown for some + // unrelated reason, must not pass as "handled". + await expect(ops.inArray(users.nickname, ['ada', 'grace'])).rejects.toThrow( + /batch query encryption returned 1 terms for 2 values/, + ) + await expect( + ops.inArray(users.nickname, ['ada', 'grace']), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + }) + + it('inArray gates on the column capability before encrypting anything', async () => { + const { ops, encryptQuery } = setup() + + await expect(ops.inArray(users.flag, [true])).rejects.toBeInstanceOf( + EncryptionOperatorError, + ) + expect(encryptQuery).not.toHaveBeenCalled() + }) + + it('and ignores undefined conditions and keeps the encrypted predicates', async () => { + const { ops, render } = setup() + const q = render( + await ops.and( + undefined, + ops.eq(users.nickname, 'ada'), + undefined, + ops.gte(users.age, 30), + ), + ) + expect(q.sql).toContain('eql_v3.eq("users"."nickname"') + expect(q.sql).toContain('eql_v3.gte("users"."age"') + expect(q.sql).toContain(' and ') + }) + + it('empty and/or resolve to their neutral predicates', async () => { + const { ops, render } = setup() + expect(render(await ops.and()).sql).toBe('true') + expect(render(await ops.or()).sql).toBe('false') + }) + + it('or combines encrypted and plain predicates', async () => { + const { ops, render } = setup() + const q = render( + await ops.or(ops.eq(users.nickname, 'ada'), drizzleEq(users.id, 1)), + ) + expect(q.sql).toContain(' or ') + expect(q.sql).toContain('eql_v3.eq("users"."nickname"') + expect(q.sql).toContain('"users"."id" = $2') + }) + + it('exports the passthrough Drizzle operators unchanged', () => { + const { ops } = setup() + expect(ops.isNull).toBe(isNull) + expect(ops.isNotNull).toBe(isNotNull) + expect(ops.not).toBe(not) + expect(ops.exists).toBe(exists) + expect(ops.notExists).toBe(notExists) + }) +}) + +describe('createEncryptionOperatorsV3 - gating errors', () => { + it('wraps encryption failures with operator context', async () => { + const { ops, encryptQuery } = setup() + encryptQuery.mockReturnValueOnce( + chainable(Promise.resolve({ failure: { message: 'bad query term' } })), + ) + + await expect(ops.eq(users.nickname, 'ada')).rejects.toMatchObject({ + name: 'EncryptionOperatorError', + }) + }) + + it('gt on an equality-only column throws', async () => { + const { ops } = setup() + await expect(ops.gt(users.nickname, 'ada')).rejects.toBeInstanceOf( + EncryptionOperatorError, + ) + }) + + it('matches on a column without a match index throws', async () => { + const { ops } = setup() + await expect(ops.matches(users.nickname, 'ada')).rejects.toThrow( + /free-text search/, + ) + }) + + it('contains on a column without JSON containment throws', async () => { + const { ops } = setup() + await expect(ops.contains(users.nickname, 'ada')).rejects.toThrow( + /JSON containment/, + ) + }) + + it('null operands throw and point callers to null checks', async () => { + const { ops } = setup() + await expect(ops.eq(users.nickname, null)).rejects.toThrow(/isNull/) + await expect(ops.matches(users.email, undefined)).rejects.toThrow(/isNull/) + }) + + it('eq on a storage-only column throws', async () => { + const { ops } = setup() + await expect(ops.eq(users.flag, true)).rejects.toBeInstanceOf( + EncryptionOperatorError, + ) + }) + + it('the equality gate reports the offending domain, as every other gate does', async () => { + const { ops } = setup() + + // Same diagnostic shape as the ore/match gates: operator, capability, + // column, and the domain that cannot answer it. + await expect(ops.eq(users.flag, true)).rejects.toThrow( + 'Operator "eq" requires equality on column "flag" (domain public.eql_v3_boolean does not support it).', + ) + await expect(ops.gt(users.nickname, 'ada')).rejects.toThrow( + 'Operator "gt" requires order/range on column "nickname" (domain public.eql_v3_text_eq does not support it).', + ) + }) + + it('asc on a non-ore column throws synchronously', () => { + const { ops } = setup() + expect(() => ops.asc(users.nickname)).toThrow(EncryptionOperatorError) + }) + + it('a non-v3 column throws', async () => { + const { ops } = setup() + await expect(ops.eq(users.id, 1)).rejects.toBeInstanceOf( + EncryptionOperatorError, + ) + }) + + it('does not treat SQLWrapper objects with column-shaped fields as Drizzle columns', async () => { + const { ops } = setup() + const spoof = { + name: 'nickname', + table: users, + getSQL: () => sql`"users"."nickname"`, + } as unknown as SQLWrapper + + await expect(ops.eq(spoof, 'ada')).rejects.toMatchObject({ + name: 'EncryptionOperatorError', + context: { columnName: 'unknown', operator: 'eq' }, + }) + }) +}) diff --git a/packages/stack-drizzle/__tests__/v3/schema-extraction.test.ts b/packages/stack-drizzle/__tests__/v3/schema-extraction.test.ts new file mode 100644 index 000000000..e3767fcc0 --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/schema-extraction.test.ts @@ -0,0 +1,111 @@ +import { encryptedTable, types as v3Types } from '@cipherstash/stack/eql/v3' +import { integer, pgTable } from 'drizzle-orm/pg-core' +import { describe, expect, it } from 'vitest' +import { extractEncryptionSchemaV3 } from '../../src/v3/schema-extraction' +import { types } from '../../src/v3/types' + +describe('extractEncryptionSchemaV3', () => { + it('rebuilds an equivalent eql/v3 encryptedTable from every drizzle v3 factory', () => { + const drizzleColumns = Object.fromEntries( + Object.entries(types).map(([factoryName, factory]) => [ + factoryName, + factory(factoryName), + ]), + ) + const authoredColumns = Object.fromEntries( + Object.entries(v3Types).map(([factoryName, factory]) => [ + factoryName, + factory(factoryName), + ]), + ) + + const extracted = extractEncryptionSchemaV3( + pgTable('users', drizzleColumns as never), + ) + const authored = encryptedTable('users', authoredColumns as never) + + expect(extracted.build()).toStrictEqual(authored.build()) + }) + + it('rebuilds an equivalent eql/v3 encryptedTable from a drizzle table', () => { + const users = pgTable('users', { + id: integer().primaryKey(), + email: types.TextSearch('email'), + age: types.IntegerOrd('age'), + }) + + const extracted = extractEncryptionSchemaV3(users) + const authored = encryptedTable('users', { + email: v3Types.TextSearch('email'), + age: v3Types.IntegerOrd('age'), + }) + + expect(extracted.build()).toStrictEqual(authored.build()) + }) + + it('keeps same-named columns on different tables bound to their own v3 domains', () => { + const accounts = pgTable('accounts', { + email: types.TextEq('email'), + }) + const metrics = pgTable('metrics', { + email: types.IntegerOrd('email'), + }) + + const accountsSchema = extractEncryptionSchemaV3(accounts) + const metricsSchema = extractEncryptionSchemaV3(metrics) + + expect(accountsSchema.build()).toStrictEqual( + encryptedTable('accounts', { + email: v3Types.TextEq('email'), + }).build(), + ) + expect(metricsSchema.build()).toStrictEqual( + encryptedTable('metrics', { + email: v3Types.IntegerOrd('email'), + }).build(), + ) + }) + + it('uses the JS property key while preserving distinct SQL column names', () => { + const users = pgTable('users', { + createdOn: types.Date('created_on'), + emailAddress: types.TextEq('email_address'), + }) + + expect(extractEncryptionSchemaV3(users).build()).toStrictEqual( + encryptedTable('users', { + createdOn: v3Types.Date('created_on'), + emailAddress: v3Types.TextEq('email_address'), + }).build(), + ) + }) + + it('uses the Drizzle column name when rebuilding fallback SQL-type columns', () => { + const table = { + [Symbol.for('drizzle:Name')]: 'users', + createdOn: { + name: 'created_on', + getSQLType: () => 'public.eql_v3_date', + }, + } + + expect(extractEncryptionSchemaV3(table as never).build()).toStrictEqual( + encryptedTable('users', { + createdOn: v3Types.Date('created_on'), + }).build(), + ) + }) + + it('throws when the table has no encrypted v3 columns', () => { + const plain = pgTable('plain', { id: integer() }) + expect(() => extractEncryptionSchemaV3(plain)).toThrow(/no encrypted v3/i) + }) + + it('throws the table-name error before checking for encrypted columns', () => { + expect(() => + extractEncryptionSchemaV3({ + secret: { getSQLType: () => 'public.eql_v3_text_eq', name: 'secret' }, + } as never), + ).toThrow('Unable to read table name from Drizzle table.') + }) +}) diff --git a/packages/stack-drizzle/__tests__/v3/sql-dialect.test.ts b/packages/stack-drizzle/__tests__/v3/sql-dialect.test.ts new file mode 100644 index 000000000..7520a672f --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/sql-dialect.test.ts @@ -0,0 +1,129 @@ +import { not, sql } from 'drizzle-orm' +import { PgDialect } from 'drizzle-orm/pg-core' +import { describe, expect, it } from 'vitest' +import { EQL_V3_FN_SCHEMA, v3Dialect } from '../../src/v3/sql-dialect' + +const dialect = new PgDialect() +const render = (s: ReturnType) => dialect.sqlToQuery(s).sql +const renderFull = (s: ReturnType) => dialect.sqlToQuery(s) +const col = sql`"users"."x"` +const enc = sql`${'{"v":"t"}'}` + +describe('v3Dialect', () => { + it('equality via HMAC', () => { + expect(render(v3Dialect.equality('eq', col, enc))).toBe( + 'eql_v3.eq("users"."x", $1)', + ) + }) + + it('inequality via HMAC', () => { + expect(render(v3Dialect.equality('ne', col, enc))).toBe( + 'eql_v3.neq("users"."x", $1)', + ) + }) + + it('comparison via ORE', () => { + expect(render(v3Dialect.comparison('gte', col, enc))).toBe( + 'eql_v3.gte("users"."x", $1)', + ) + }) + + it('range via ORE, parenthesised so it survives negation', () => { + const lo = sql`${'{"v":"lo"}'}` + const hi = sql`${'{"v":"hi"}'}` + expect(render(v3Dialect.range(col, lo, hi))).toBe( + '(eql_v3.gte("users"."x", $1) AND eql_v3.lte("users"."x", $2))', + ) + }) + + it('a negated range negates the whole conjunction, not just its first term', () => { + const lo = sql`${'{"v":"lo"}'}` + const hi = sql`${'{"v":"hi"}'}` + + // Drizzle's `not` renders `not ${condition}` with no parentheses of its + // own. Postgres binds NOT tighter than AND, so an unparenthesised range + // would silently become `(NOT gte) AND lte`. + expect(render(not(v3Dialect.range(col, lo, hi)))).toBe( + 'not (eql_v3.gte("users"."x", $1) AND eql_v3.lte("users"."x", $2))', + ) + }) + + it('contains via two-arg function', () => { + expect(render(v3Dialect.contains(col, enc))).toBe( + 'eql_v3.contains("users"."x", $1)', + ) + }) + + it('orderBy extracts the ord term', () => { + expect(render(v3Dialect.orderBy(col))).toBe('eql_v3.ord_term("users"."x")') + }) + + // `render` above discards `.params`, so nothing here proved a value was BOUND + // rather than concatenated into the SQL text. The only `sql.raw` in the + // dialect interpolates constants (the schema + function name), so no + // injectable path exists today — these pin that. + describe('operand values are bound, never interpolated into SQL text', () => { + const hostile = '{"v":"\\" OR 1=1 --","x":"$1","y":"back\\\\slash"}' + + it.each([ + ['equality', () => v3Dialect.equality('eq', col, sql`${hostile}`)], + ['comparison', () => v3Dialect.comparison('gte', col, sql`${hostile}`)], + ['contains', () => v3Dialect.contains(col, sql`${hostile}`)], + // `$1` in a title is consumed by vitest as an index into the case tuple, + // so it cannot be used to name the SQL placeholder here. + ])('%s binds a hostile operand as a positional parameter', (_name, build) => { + const query = renderFull(build()) + + expect(query.params).toEqual([hostile]) + expect(query.sql).toContain('$1') + // The raw value must appear nowhere in the SQL text. + expect(query.sql).not.toContain('OR 1=1') + expect(query.sql).not.toContain('back\\slash') + }) + + it('range binds both bounds positionally, min first', () => { + const query = renderFull( + v3Dialect.range(col, sql`${'{"b":"min"}'}`, sql`${'{"b":"max"}'}`), + ) + + expect(query.params).toEqual(['{"b":"min"}', '{"b":"max"}']) + expect(query.sql).toBe( + '(eql_v3.gte("users"."x", $1) AND eql_v3.lte("users"."x", $2))', + ) + }) + + it('binds a large ciphertext without truncating or inlining it', () => { + const big = `{"c":"${'z'.repeat(16384)}"}` + const query = renderFull(v3Dialect.equality('eq', col, sql`${big}`)) + + expect(query.params).toEqual([big]) + expect(query.sql).toBe('eql_v3.eq("users"."x", $1)') + }) + }) + + it('every helper schema-qualifies its function call', () => { + const lo = sql`${'{"v":"lo"}'}` + const hi = sql`${'{"v":"hi"}'}` + const fragments = [ + render(v3Dialect.equality('eq', col, enc)), + render(v3Dialect.equality('ne', col, enc)), + render(v3Dialect.comparison('gte', col, enc)), + render(v3Dialect.contains(col, enc)), + render(v3Dialect.orderBy(col)), + ] + + // Deliberately asserts the LITERAL prefix, not `${EQL_V3_FN_SCHEMA}.`. + // Deriving the expectation from the constant under test would hold for any + // value of that constant — including a wrong one. + for (const fragment of fragments) { + expect(fragment.startsWith('eql_v3.')).toBe(true) + } + // `range` invokes two functions, neither of them leading the fragment. + expect( + (render(v3Dialect.range(col, lo, hi)).match(/eql_v3\./g) ?? []).length, + ).toBe(2) + // The constant is the single knob those literals must agree with, so a + // one-line schema move fails here first and loudly. + expect(EQL_V3_FN_SCHEMA).toBe('eql_v3') + }) +}) diff --git a/packages/stack-drizzle/__tests__/v3/types.test-d.ts b/packages/stack-drizzle/__tests__/v3/types.test-d.ts new file mode 100644 index 000000000..55b8022c2 --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/types.test-d.ts @@ -0,0 +1,42 @@ +import type { types as v3Types } from '@cipherstash/stack/eql/v3' +import type { Encrypted } from '@cipherstash/stack/types' +import { describe, expectTypeOf, it } from 'vitest' +import { types } from '../../src/v3/types' + +describe('v3 drizzle types - type-level', () => { + it('exposes exactly the same factory keys as @/eql/v3 types', () => { + expectTypeOf().toEqualTypeOf() + }) + + it('types the data slot as the encrypted envelope, not plaintext (A3)', () => { + // The value stored/inserted/selected is the ENCRYPTED EQL v3 jsonb envelope, + // NOT the column's plaintext. So every concrete domain — regardless of its + // plaintext axis (number/Date/boolean/string) — exposes `Encrypted` in its + // Drizzle `data` slot. Plaintext inference is a separate concern, proven on + // the v3 core builder via `PlaintextForColumn` (see schema-v3.test-d.ts). + expectTypeOf(types.IntegerOrd('age')._.data).toEqualTypeOf() + expectTypeOf(types.IntegerEq('age_eq')._.data).toEqualTypeOf() + expectTypeOf(types.BigintOrd('big')._.data).toEqualTypeOf() + expectTypeOf(types.DateOrd('created_at')._.data).toEqualTypeOf() + expectTypeOf(types.Timestamp('ts')._.data).toEqualTypeOf() + expectTypeOf(types.Boolean('flag')._.data).toEqualTypeOf() + expectTypeOf(types.TextEq('nickname')._.data).toEqualTypeOf() + expectTypeOf(types.TextSearch('search')._.data).toEqualTypeOf() + expectTypeOf(types.DoubleOrd('d')._.data).toEqualTypeOf() + }) + + it('does not expose obsolete pre-0.27 concrete domain names', () => { + // @ts-expect-error - use IntegerOrd + types.Int4Ord('age') + // @ts-expect-error - use SmallintOrd + types.Int2Ord('age') + // @ts-expect-error - use Timestamp + types.Timestamptz('created_at') + // @ts-expect-error - use Boolean + types.Bool('active') + // @ts-expect-error - use RealEq + types.Float4Eq('score') + // @ts-expect-error - use DoubleOrd + types.Float8Ord('score') + }) +}) diff --git a/packages/stack-drizzle/__tests__/v3/types.test.ts b/packages/stack-drizzle/__tests__/v3/types.test.ts new file mode 100644 index 000000000..face747e1 --- /dev/null +++ b/packages/stack-drizzle/__tests__/v3/types.test.ts @@ -0,0 +1,22 @@ +import { types as v3Types } from '@cipherstash/stack/eql/v3' +import { describe, expect, it } from 'vitest' +import { getEqlV3Column } from '../../src/v3/column' +import { types } from '../../src/v3/types' + +describe('v3 drizzle types namespace', () => { + it('exposes the same factory names as @/eql/v3 types', () => { + expect(Object.keys(types).sort()).toEqual(Object.keys(v3Types).sort()) + }) + + it.each( + Object.entries(types), + )('%s mirrors the authoring DSL and recovers the concrete eql type', (factoryName, factory) => { + const drizzleColumn = factory(factoryName) + const authoredColumn = + v3Types[factoryName as keyof typeof v3Types](factoryName) + + expect(getEqlV3Column(factoryName, drizzleColumn)?.getEqlType()).toBe( + authoredColumn.getEqlType(), + ) + }) +}) diff --git a/packages/stack-drizzle/integration/adapter.ts b/packages/stack-drizzle/integration/adapter.ts new file mode 100644 index 000000000..524ad33d1 --- /dev/null +++ b/packages/stack-drizzle/integration/adapter.ts @@ -0,0 +1,221 @@ +import { EncryptionV3 } from '@cipherstash/stack/v3' +import { + databaseUrl, + type IntegrationAdapter, + type PlainRow, + type QueryOp, + type QueryOpKind, + type TableSpec, +} from '@cipherstash/test-kit' +import { asc, type SQL } from 'drizzle-orm' +import { type PgTable, pgTable, text } from 'drizzle-orm/pg-core' +import { drizzle } from 'drizzle-orm/postgres-js' +import postgres from 'postgres' +import { makeEqlV3Column } from '../src/v3/column' +import { + createEncryptionOperatorsV3, + extractEncryptionSchemaV3, +} from '../src/v3/index.js' + +/** + * The Drizzle v3 adapter under real ZeroKMS ciphertext. + * + * The counterpart to the Supabase adapter, driven by the same catalog, the same + * plaintext oracle and the same driver — so the two cannot quietly cover + * different operations while both read as "comprehensive". Where they legitimately + * differ, they differ in `supportedOps`, not in what a shared test asserts. + * + * Ordering is the interesting case. Drizzle emits the canonical EQL form, + * `ORDER BY eql_v3.ord_term(col)`, straight from `sql-dialect.ts`. Supabase + * cannot call a function through PostgREST and orders the same term through the + * jsonb path `col->op`. Both must satisfy the identical oracle. + */ + +const SUPPORTED_OPS: ReadonlySet = new Set([ + 'eq', + 'ne', + 'in', + 'notIn', + 'gt', + 'gte', + 'lt', + 'lte', + 'between', + 'notBetween', + 'matches', + 'order', + 'isNull', + 'isNotNull', +]) + +/** Drizzle talks straight to Postgres; nothing is refused adapter-wide. */ +const ALWAYS_REJECTED: ReadonlySet = new Set() + +// biome-ignore lint/suspicious/noExplicitAny: the table shape is built per family at runtime +type AnyTable = any + +export function makeDrizzleAdapter(): IntegrationAdapter { + let sqlClient: postgres.Sql + let db: ReturnType + let client: Awaited> + let ops: ReturnType + let table: AnyTable + let schema: ReturnType + let tableName: string + + const column = (slug: string) => table[slug] + + /** Every op except `order` resolves to a WHERE condition. */ + const conditionFor = async (op: QueryOp): Promise => { + const col = column(op.column) + switch (op.kind) { + case 'eq': + return ops.eq(col, op.value as never) + case 'ne': + return ops.ne(col, op.value as never) + case 'gt': + return ops.gt(col, op.value as never) + case 'gte': + return ops.gte(col, op.value as never) + case 'lt': + return ops.lt(col, op.value as never) + case 'lte': + return ops.lte(col, op.value as never) + case 'in': + // Drizzle has no raw-filter path; `asRawFilter` is a Supabase concern. + return ops.inArray(col, [...op.values] as never) + case 'notIn': + return ops.notInArray(col, [...op.values] as never) + case 'between': + return ops.between(col, op.lo as never, op.hi as never) + case 'notBetween': + return ops.notBetween(col, op.lo as never, op.hi as never) + case 'matches': + return ops.matches(col, op.needle as never) + case 'isNull': + return ops.isNull(col) + case 'isNotNull': + return ops.isNotNull(col) + case 'order': + throw new Error('order is a transform, not a condition') + } + } + + const selectRowKeys = async (where: SQL | undefined, orderBy: SQL[]) => { + const rows = (await db + .select({ rowKey: table.rowKey }) + .from(table as PgTable) + .where(where) + .orderBy(...orderBy)) as Array<{ rowKey: string }> + return rows.map((row) => row.rowKey) + } + + return { + name: 'drizzle', + supportedOps: SUPPORTED_OPS, + alwaysRejectedOps: ALWAYS_REJECTED, + + async setup() { + sqlClient = postgres(databaseUrl(), { prepare: false }) + db = drizzle({ client: sqlClient }) + // `client` and `ops` are built in `createTable`: the encryption client is + // constructed from the table's schema, which does not exist yet. + }, + + async teardown() { + if (tableName) await sqlClient.unsafe(`DROP TABLE IF EXISTS ${tableName}`) + await sqlClient.end() + }, + + async createTable(spec: TableSpec) { + tableName = spec.name + + const columns = Object.fromEntries( + spec.columns.map((c) => [ + c.slug, + makeEqlV3Column(c.spec.builder(c.slug)), + ]), + ) + table = pgTable(spec.name, { + rowKey: text('row_key').primaryKey(), + ...columns, + }) + schema = extractEncryptionSchemaV3(table) + + // The DDL comes from the column builders, not from a hand-written list, so + // a domain rename cannot silently desync the table from the schema. + const ddl = spec.columns + .map((c) => `"${c.slug}" ${c.eqlType}`) + .join(',\n ') + await sqlClient.unsafe(`DROP TABLE IF EXISTS ${spec.name}`) + await sqlClient.unsafe(` + CREATE TABLE ${spec.name} ( + row_key TEXT PRIMARY KEY, + ${ddl} + ) + `) + + // The client must know this table's schema to encrypt for it. Rebuilt per + // family, since each family has its own columns. + client = await EncryptionV3({ schemas: [schema as never] }) + ops = createEncryptionOperatorsV3(client) + }, + + async insertSingle(_spec: TableSpec, row: PlainRow) { + const result = await client.encryptModel( + { rowKey: row.rowKey, ...row.values } as never, + schema as never, + ) + if (result.failure) { + throw new Error( + `insertSingle(${row.rowKey}): ${result.failure.message}`, + ) + } + await db.insert(table as PgTable).values(result.data as never) + }, + + async insertBulk(_spec: TableSpec, rows: readonly PlainRow[]) { + const models = rows.map((row) => ({ rowKey: row.rowKey, ...row.values })) + const result = await client.bulkEncryptModels( + models as never, + schema as never, + ) + if (result.failure) + throw new Error(`insertBulk: ${result.failure.message}`) + await db.insert(table as PgTable).values(result.data as never) + }, + + async run(_spec: TableSpec, op: QueryOp): Promise { + if (op.kind === 'order') { + const col = column(op.column) + const term = op.direction === 'asc' ? ops.asc(col) : ops.desc(col) + // Exclude the all-NULL row, and break ties on `row_key` — the oracle + // does both. Domains with fewer distinct samples than rows give two rows + // the same plaintext, so the term alone does not determine their order. + return selectRowKeys(await ops.isNotNull(col), [ + term as SQL, + asc(table.rowKey), + ]) + } + + return selectRowKeys(await conditionFor(op), [asc(table.rowKey)]) + }, + + async expectRejected(_spec: TableSpec, op: QueryOp) { + try { + if (op.kind === 'order') { + const col = column(op.column) + // `asc`/`desc` throw synchronously on a column with no ordering term. + void (op.direction === 'asc' ? ops.asc(col) : ops.desc(col)) + } else { + await conditionFor(op) + } + } catch { + return // an `EncryptionOperatorError` is the rejection + } + throw new Error( + `Expected ${op.kind}("${op.column}") to be rejected, but it succeeded`, + ) + }, + } +} diff --git a/packages/stack-drizzle/integration/families.integration.test.ts b/packages/stack-drizzle/integration/families.integration.test.ts new file mode 100644 index 000000000..e04683011 --- /dev/null +++ b/packages/stack-drizzle/integration/families.integration.test.ts @@ -0,0 +1,12 @@ +import { FAMILY_NAMES } from '@cipherstash/test-kit' +import { runFamilySuite } from '@cipherstash/test-kit/suite' +import { makeDrizzleAdapter } from './adapter' + +/** + * Every EQL v3 domain the SDK models, driven through the Drizzle adapter against + * real ZeroKMS ciphertext — the same catalog, oracle and driver as the Supabase + * suite, so the two cannot claim different coverage. + */ +for (const family of FAMILY_NAMES) { + runFamilySuite(family, makeDrizzleAdapter) +} diff --git a/packages/stack-drizzle/integration/json-contains.integration.test.ts b/packages/stack-drizzle/integration/json-contains.integration.test.ts new file mode 100644 index 000000000..de3e7b391 --- /dev/null +++ b/packages/stack-drizzle/integration/json-contains.integration.test.ts @@ -0,0 +1,126 @@ +/** + * Live JSON containment for the v3 `types.Json()` column through the Drizzle + * operators. Seeds encrypted JSONB documents and queries them with + * `ops.contains(col, subObject)` — EXACT containment (distinct from the fuzzy + * `ops.matches` used for text search). On a `json` column it emits the `@>` + * operator over the encrypted JSONB document (json has no `eql_v3.contains` + * overload) with a `query_jsonb` needle from `encryptQuery` — asserting it + * returns exactly the rows whose document contains the sub-object (jsonb `@>` + * semantics), and excludes the rest. + */ + +import type { JsonDocument } from '@cipherstash/stack/eql/v3' +import { EncryptionV3 } from '@cipherstash/stack/v3' +import { databaseUrl, unwrapResult } from '@cipherstash/test-kit' +import { and, asc, eq, type SQL } from 'drizzle-orm' +import { integer, pgTable, text } from 'drizzle-orm/pg-core' +import { drizzle } from 'drizzle-orm/postgres-js' +import postgres from 'postgres' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { + createEncryptionOperatorsV3, + extractEncryptionSchemaV3, + types, +} from '../src/v3/index.js' + +const sqlClient = postgres(databaseUrl(), { prepare: false }) + +const TABLE_NAME = 'protect_ci_v3_json_contains' +const RUN = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` + +const docTable = pgTable(TABLE_NAME, { + id: integer('id').primaryKey().generatedAlwaysAsIdentity(), + rowKey: text('row_key').notNull(), + testRunId: text('test_run_id').notNull(), + doc: types.Json('doc'), +}) + +const schema = extractEncryptionSchemaV3(docTable) + +// Distinct documents so each containment query has a definite expected set. +const DOCS: Record = { + ada: { user: 'ada@example.com', roles: ['admin', 'eng'], active: true }, + grace: { user: 'grace@example.com', roles: ['eng'] }, + zoe: { user: 'zoe@example.com', roles: ['ops'], active: false }, +} + +type SelectRow = { rowKey: string } +let client: Awaited> +let ops: ReturnType +let db: ReturnType + +async function matching(condition: SQL): Promise { + const rows = (await db + .select({ rowKey: docTable.rowKey }) + .from(docTable) + .where(and(eq(docTable.testRunId, RUN), condition)) + .orderBy(asc(docTable.rowKey))) as SelectRow[] + return rows.map((row) => row.rowKey) +} + +beforeAll(async () => { + // EQL v3 is installed once per run by `global-setup.ts`. + client = await EncryptionV3({ schemas: [schema] }) + ops = createEncryptionOperatorsV3(client) + db = drizzle({ client: sqlClient }) + + await sqlClient.unsafe(`DROP TABLE IF EXISTS ${TABLE_NAME}`) + await sqlClient.unsafe(` + CREATE TABLE ${TABLE_NAME} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + row_key TEXT NOT NULL, + test_run_id TEXT NOT NULL, + doc public.eql_v3_json NOT NULL + ) + `) + + const rows = Object.entries(DOCS).map(([rowKey, doc]) => ({ + rowKey, + testRunId: RUN, + doc, + })) + const encrypted = unwrapResult( + await client.bulkEncryptModels(rows, schema), + ) as Array> + await db.insert(docTable).values(encrypted as never) +}, 120000) + +afterAll(async () => { + await sqlClient`DELETE FROM ${sqlClient(TABLE_NAME)} WHERE test_run_id = ${RUN}` + await sqlClient.end() +}, 30000) + +describe('v3 drizzle JSON containment (live pg)', () => { + it('matches every document containing a sub-object (array element containment)', async () => { + // `{ roles: ['eng'] }` ⊆ ada (admin,eng) and grace (eng), not zoe (ops). + const condition = await ops.contains(docTable.doc, { roles: ['eng'] }) + expect(await matching(condition)).toEqual(['ada', 'grace']) + }, 30000) + + it('matches on a scalar field', async () => { + const condition = await ops.contains(docTable.doc, { + user: 'zoe@example.com', + }) + expect(await matching(condition)).toEqual(['zoe']) + }, 30000) + + it('matches on a nested boolean', async () => { + const condition = await ops.contains(docTable.doc, { active: true }) + expect(await matching(condition)).toEqual(['ada']) + }, 30000) + + it('returns nothing for a sub-object no document contains', async () => { + const condition = await ops.contains(docTable.doc, { roles: ['nope'] }) + expect(await matching(condition)).toEqual([]) + }, 30000) + + // `doc @> '{}'` holds for every row (jsonb `{} ⊆ anything`), so an empty-object + // needle would silently return the whole table — the same whole-table footgun + // the bloom path rejects. The operator must refuse it before querying, rather + // than leak every row. + it('rejects an empty-object needle before querying', async () => { + await expect(ops.contains(docTable.doc, {})).rejects.toThrow( + /matches every row/, + ) + }, 30000) +}) diff --git a/packages/stack-drizzle/integration/lock-context.integration.test.ts b/packages/stack-drizzle/integration/lock-context.integration.test.ts new file mode 100644 index 000000000..293c34853 --- /dev/null +++ b/packages/stack-drizzle/integration/lock-context.integration.test.ts @@ -0,0 +1,357 @@ +/** + * Live, identity-bound querying through the v3 Drizzle operator path. + * + * `matrix-identity-live.test.ts` proves lock context round-trips through the + * typed CLIENT (`encryptModel`/`decryptModel`), and `operators.test.ts` proves + * the Drizzle operators FORWARD `lockContext`/`audit` — but only against a + * MOCKED FFI. Nothing exercises the one end-to-end shape that matters most: + * seed rows bound to an identity, then query them with `ops.eq(col, value, + * { lockContext })` against a real database and assert the encrypted term + * actually matches the stored row and decrypts. + * + * The client authenticates via `OidcFederationStrategy`, federating a + * freshly-minted Clerk M2M JWT (`clerkJwtProvider()`) into a CTS token, and + * binds the key to the `sub` claim — resolved by ZeroKMS from the token, here + * the Clerk machine identity — with a plain `.withLockContext({ identityClaim })`. + * + * Lives under `integration/identity/`: like every integration suite it THROWS + * rather than skips when unconfigured (`clerkJwtProvider()` asserts + * `CLERK_MACHINE_TOKEN`). Whether the searchable index terms are themselves + * identity-bound is decided inside `@cipherstash/protect-ffi`, not this repo. + * + * We assert the symmetric behaviour (same lock context on seed + query matches + * and decrypts) AND the negative path. The boundary is at DECRYPTION: an + * identity-bound row must not decrypt without its context. Search is NOT the + * boundary — the equality term is workspace-scoped, so a no-context query still + * matches (see the negative-path tests). The symmetric tests alone are + * insufficient: they drop the context identically on both sides, so they stay + * green even if it were ignored entirely. + * + * The cross-identity non-match (sealed under A, decrypted under B) is covered by + * the final test: it federates a SECOND Clerk machine (`CLERK_MACHINE_TOKEN_B`, + * a distinct `sub`) and asserts B cannot read A's row, with A reading it as the + * control. + */ +import { OidcFederationStrategy } from '@cipherstash/stack' +import { EncryptionV3 } from '@cipherstash/stack/v3' +import { databaseUrl, unwrapResult, V3_MATRIX } from '@cipherstash/test-kit' +import { clerkJwtProvider } from '@cipherstash/test-kit/integration-clerk' +import { and, asc as drizzleAsc, eq as drizzleEq, type SQL } from 'drizzle-orm' +import { integer, pgTable, text } from 'drizzle-orm/pg-core' +import { drizzle } from 'drizzle-orm/postgres-js' +import postgres from 'postgres' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { makeEqlV3Column } from '../src/v3/column' +import { + createEncryptionOperatorsV3, + extractEncryptionSchemaV3, +} from '../src/v3/index.js' + +const sqlClient = postgres(databaseUrl(), { prepare: false }) + +const TABLE_NAME = 'protect_ci_v3_drizzle_lock_context' +const RUN = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` +const ROW_A = 'row-a' +const ROW_B = 'row-b' +const SECRET_A = 'ada@example.com' +const SECRET_B = 'grace@example.com' + +// A fixed identity claim; the same value must be supplied on encrypt and query +// for the terms/keys to reproduce. +const IDENTITY_CLAIM = { identityClaim: ['sub'] } + +const secretTable = pgTable(TABLE_NAME, { + id: integer('id').primaryKey().generatedAlwaysAsIdentity(), + rowKey: text('row_key').notNull(), + testRunId: text('test_run_id').notNull(), + secret: makeEqlV3Column(V3_MATRIX['public.eql_v3_text_eq'].builder('secret')), +} as never) + +const schema = extractEncryptionSchemaV3(secretTable) + +type SelectRow = { rowKey: string } + +let client: Awaited> +let ops: ReturnType +let db: ReturnType + +/** + * The outcome of a decrypt attempt that is EXPECTED to be denied. `decrypt` + * reports denial as a `Result.failure` rather than throwing, so a bare `await` + * would resolve and a naive `expect(...).rejects` would never fire — denial has + * to be read off the result. A throw also counts as denial. + * + * Returns the message, not just a boolean, so callers can assert WHY it was + * denied. A bare boolean would let any infrastructure fault — a DNS failure, an + * expired CTS token, a ZeroKMS outage ("SendRequest: Failed to send request") — + * read as "the identity boundary held", and the security test would pass for + * the wrong reason. + */ +async function decryptOutcome( + attempt: () => PromiseLike<{ failure?: { message: string } }>, +): Promise<{ denied: boolean; message: string }> { + try { + const result = await attempt() + return { + denied: Boolean(result.failure), + message: result.failure?.message ?? '', + } + } catch (error) { + return { denied: true, message: (error as Error).message } + } +} + +/** + * A genuine key-derivation denial. ZeroKMS cannot reproduce the key tag without + * the identity claim the row was sealed under, and says so. Asserted verbatim + * elsewhere in the suite (`lock-context.test.ts`, `protect-ops.test.ts`). + */ +const KEY_DENIAL = /^Failed to retrieve key/ + +/** + * Denial under a claim the token may not carry at all. Naming a claim does not + * assert it exists: `resolveLockContext` is a passthrough, and ZeroKMS resolves + * the claim's value from the authenticating token. So decrypting under + * `['email']` a row sealed under `['sub']` either fails key derivation, or — if + * the token has no `email` claim — is refused by the authorization layer before + * key derivation is ever attempted. Both are denials; which one surfaces is a + * ZeroKMS server-side detail we do not pin. + * + * What must NOT pass is an infrastructure fault masquerading as a denial, so + * that is excluded separately. Kept loose rather than pinned to `KEY_DENIAL` + * because which of the two denials surfaces is a ZeroKMS server-side detail, + * and the Clerk machine token may or may not carry an `email` claim. + */ +const IDENTITY_DENIAL = + /failed to retrieve key|unauthoriz|unauthoris|forbidden|denied|not authorized|not authorised/i + +/** A transport/outage failure, which must never be mistaken for a denial. */ +const INFRA_FAULT = + /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|timed? ?out|network error/i + +/** Run-scoped SELECT of row keys under an already-encrypted SQL condition. */ +async function selectRowKeys(condition: SQL): Promise { + const rows = (await db + .select({ rowKey: secretTable.rowKey }) + .from(secretTable) + .where(and(drizzleEq(secretTable.testRunId, RUN), condition)) + .orderBy(drizzleAsc(secretTable.rowKey))) as SelectRow[] + return rows.map((row) => row.rowKey) +} + +beforeAll(async () => { + const crn = process.env.CS_WORKSPACE_CRN + if (!crn) + throw new Error('CS_WORKSPACE_CRN must be set for lock-context tests') + + // A freshly-minted Clerk M2M JWT federates into a CTS token; the strategy + // re-mints via this callback on expiry. `clerkJwtProvider()` asserts + // CLERK_MACHINE_TOKEN (throws if absent). EQL v3 is installed once per run by + // `global-setup.ts`. + // + // `create()` returns a `Result` — unwrap to the strategy itself, which is what + // `config.authStrategy` expects (it calls `.getToken()` on it). + const federation = OidcFederationStrategy.create(crn, clerkJwtProvider()) + if (federation.failure) { + throw new Error(`[federation]: ${federation.failure.message}`) + } + client = await EncryptionV3({ + schemas: [schema], + config: { authStrategy: federation.data }, + }) + ops = createEncryptionOperatorsV3(client) + db = drizzle({ client: sqlClient }) + + await sqlClient.unsafe(` + CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + row_key TEXT NOT NULL, + test_run_id TEXT NOT NULL, + secret public.eql_v3_text_eq NOT NULL + ) + `) + + // Seed BOTH rows bound to the same lock context. + const encryptedRows = unwrapResult>>( + await client + .bulkEncryptModels( + [ + { rowKey: ROW_A, testRunId: RUN, secret: SECRET_A }, + { rowKey: ROW_B, testRunId: RUN, secret: SECRET_B }, + ] as never, + schema, + ) + .withLockContext(IDENTITY_CLAIM), + ) + await db.insert(secretTable).values(encryptedRows as never) +}, 120000) + +afterAll(async () => { + await sqlClient`DELETE FROM ${sqlClient(TABLE_NAME)} WHERE test_run_id = ${RUN}` + await sqlClient.end() +}, 30000) + +describe('v3 drizzle operators with lock context (live pg)', () => { + it('eq with a matching lock context selects the exact row', async () => { + const condition = await ops.eq(secretTable.secret, SECRET_A, { + // Runtime accepts a plain { identityClaim } (forwarded to + // withLockContext); the operator opts type is narrowed to LockContext. + lockContext: IDENTITY_CLAIM as never, + }) + expect(await selectRowKeys(condition)).toEqual([ROW_A]) + }, 30000) + + it('a lock-context-bound row decrypts with the same lock context', async () => { + const [row] = await sqlClient.unsafe>( + `SELECT secret::jsonb AS value FROM ${TABLE_NAME} + WHERE test_run_id = $1 AND row_key = $2`, + [RUN, ROW_A], + ) + expect(row).toBeDefined() + + const decrypted = unwrapResult( + await client.decrypt(row.value as never).withLockContext(IDENTITY_CLAIM), + ) + expect(decrypted).toBe(SECRET_A) + }, 30000) + + it('eq threads an audit config alongside the lock context', async () => { + const condition = await ops.eq(secretTable.secret, SECRET_B, { + lockContext: IDENTITY_CLAIM as never, + audit: { metadata: { sub: 'toby@cipherstash.com', type: 'query' } }, + }) + expect(await selectRowKeys(condition)).toEqual([ROW_B]) + }, 30000) + + // NEGATIVE PATH. The identity boundary is enforced at DECRYPTION, not at + // search. The equality term (`hm`/`eq_term` HMAC) is workspace-scoped: a query + // WITHOUT the lock context produces the same term and matches the same row — + // but the value still cannot be decrypted without the context (second test + // below). To run the no-context query at all you must already know the + // plaintext to build the term, and you can confirm a match but never read the + // row. + // + // Whether search terms SHOULD be identity-bound is a CipherStash design + // question, raised with the team. An earlier version of the first test + // assumed they were and asserted `[]`; this is corrected to the OBSERVED + // behaviour, with the real boundary proven by the decryption test. + // + // The true CROSS-identity proof (sealed under A, decrypted under B) needs a + // SECOND machine identity with a different `sub`; the lock context only names + // the claim (`['sub']`) while ZeroKMS resolves its value from the + // authenticating token. That is the final test in this suite, federating + // `CLERK_MACHINE_TOKEN_B`. + it('an eq matches the same row with or without a lock context (search is not identity-bound)', async () => { + const bound = await ops.eq(secretTable.secret, SECRET_A, { + lockContext: IDENTITY_CLAIM as never, + }) + expect(await selectRowKeys(bound)).toEqual([ROW_A]) + + // Same HMAC term, no context — still matches. Decryption, not search, is + // the identity boundary (proven by the next test). + const unbound = await ops.eq(secretTable.secret, SECRET_A) + expect(await selectRowKeys(unbound)).toEqual([ROW_A]) + }, 30000) + + it('an identity-bound row does not decrypt without its lock context', async () => { + const [row] = await sqlClient.unsafe>( + `SELECT secret::jsonb AS value FROM ${TABLE_NAME} + WHERE test_run_id = $1 AND row_key = $2`, + [RUN, ROW_A], + ) + + // A missing fixture would make `row.value` throw a TypeError inside + // `decryptOutcome`, which counts a throw as denial. The message assertions + // below already reject that string, so the test fails either way — but it + // fails blaming the denial regex. Name the real fault here instead. + expect(row).toBeDefined() + + // `decrypt` reports denial as a `Result.failure` and does not throw, so a + // bare `await` here would silently pass. Require denial via either channel, + // AND require it be a key-derivation denial rather than an outage. + const { denied, message } = await decryptOutcome(() => + client.decrypt(row.value as never), + ) + + expect(denied).toBe(true) + expect(message).toMatch(KEY_DENIAL) + }, 30000) + + it('an identity-bound row does not decrypt under a different identity claim', async () => { + const [row] = await sqlClient.unsafe>( + `SELECT secret::jsonb AS value FROM ${TABLE_NAME} + WHERE test_run_id = $1 AND row_key = $2`, + [RUN, ROW_A], + ) + + expect(row).toBeDefined() + + const { denied, message } = await decryptOutcome(() => + client + .decrypt(row.value as never) + .withLockContext({ identityClaim: ['email'] } as never), + ) + + expect(denied).toBe(true) + expect(message).toMatch(IDENTITY_DENIAL) + expect(message).not.toMatch(INFRA_FAULT) + }, 30000) + + // The true cross-identity proof: same `['sub']` claim, a DIFFERENT + // authenticating machine. Everything above uses one identity, so it cannot + // tell "bound to A" from "bound to nothing" — this can. Machine B must be a + // distinct machine (its own `sub`) in the same Clerk instance registered on + // the workspace; `clerkJwtProvider('CLERK_MACHINE_TOKEN_B')` throws if that + // token is unset, so this fails loudly rather than skipping. + it('a row sealed under identity A does not decrypt under a different identity (B)', async () => { + const crn = process.env.CS_WORKSPACE_CRN as string + const federationB = OidcFederationStrategy.create( + crn, + clerkJwtProvider('CLERK_MACHINE_TOKEN_B'), + ) + if (federationB.failure) { + throw new Error(`[federation B]: ${federationB.failure.message}`) + } + const clientB = await EncryptionV3({ + schemas: [schema], + config: { authStrategy: federationB.data }, + }) + + const [row] = await sqlClient.unsafe>( + `SELECT secret::jsonb AS value FROM ${TABLE_NAME} + WHERE test_run_id = $1 AND row_key = $2`, + [RUN, ROW_A], + ) + expect(row).toBeDefined() + + // Control: identity A reads its own row. If this is denied, A's federation + // or the fixture is broken and the cross-identity assertion below would + // "pass" for the wrong reason. + const asA = await decryptOutcome(() => + client.decrypt(row.value as never).withLockContext(IDENTITY_CLAIM), + ) + expect( + asA.denied, + `identity A must read its own row (got: ${asA.message})`, + ).toBe(false) + + // Cross-identity: B names the same `['sub']` claim, but its value is B's + // machine, so ZeroKMS derives a DIFFERENT key and refuses — a genuine + // key-derivation denial (`Failed to retrieve key`). Pin to KEY_DENIAL, NOT + // the broad IDENTITY_DENIAL: B is a valid, registered machine, so it + // authenticates fine and the denial must surface at key derivation. Were B + // instead rejected at the authorization layer (e.g. its machine not + // registered on the workspace), that "unauthorized" message would satisfy + // IDENTITY_DENIAL and the test would pass GREEN without ever exercising the + // identity boundary — proving "B can't authenticate", not "B can't reproduce + // A's key". + const asB = await decryptOutcome(() => + clientB.decrypt(row.value as never).withLockContext(IDENTITY_CLAIM), + ) + expect(asB.denied, 'identity B must NOT decrypt a row sealed under A').toBe( + true, + ) + expect(asB.message).toMatch(KEY_DENIAL) + expect(asB.message).not.toMatch(INFRA_FAULT) + }, 30000) +}) diff --git a/packages/stack-drizzle/integration/null-persistence.integration.test.ts b/packages/stack-drizzle/integration/null-persistence.integration.test.ts new file mode 100644 index 000000000..6534c60ac --- /dev/null +++ b/packages/stack-drizzle/integration/null-persistence.integration.test.ts @@ -0,0 +1,182 @@ +/** + * Live NULL persistence for encrypted columns across every capability tier. + * + * `operators-live-pg.test.ts` proves `isNull`/`isNotNull` — but only for a + * single `text_eq` column (`nullableTextEq`). NULL storage and retrieval for + * the other tiers (storage-only, order/ORE, free-text match) is untested live: + * a bug that mangled a NULL cell, or a domain that rejected NULL, would only + * show up on those column kinds. + * + * This file seeds two rows — row A all-NULL, row B all-present — across one + * representative column per tier, then asserts, per column: `isNull` selects + * the NULL row, `isNotNull` selects the present row, the NULL cell reads back + * as SQL NULL, and the present cell still decrypts to its plaintext. + */ + +import { EncryptionV3 } from '@cipherstash/stack/v3' +import { databaseUrl, V3_MATRIX } from '@cipherstash/test-kit' +import { and, asc as drizzleAsc, eq as drizzleEq, type SQL } from 'drizzle-orm' +import { integer, pgTable, text } from 'drizzle-orm/pg-core' +import { drizzle } from 'drizzle-orm/postgres-js' +import postgres from 'postgres' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { makeEqlV3Column } from '../src/v3/column' +import { + createEncryptionOperatorsV3, + extractEncryptionSchemaV3, +} from '../src/v3/index.js' + +const sqlClient = postgres(databaseUrl(), { prepare: false }) + +const TABLE_NAME = 'protect_ci_v3_drizzle_nullable' +const RUN = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` +const ROW_A = 'row-a' // all NULL +const ROW_B = 'row-b' // all present + +// One representative column per capability tier, each NULLABLE. +const nullableTable = pgTable(TABLE_NAME, { + id: integer('id').primaryKey().generatedAlwaysAsIdentity(), + rowKey: text('row_key').notNull(), + testRunId: text('test_run_id').notNull(), + storageText: makeEqlV3Column( + V3_MATRIX['public.eql_v3_text'].builder('storage_text'), + ), + eqText: makeEqlV3Column( + V3_MATRIX['public.eql_v3_text_eq'].builder('eq_text'), + ), + ordInt: makeEqlV3Column( + V3_MATRIX['public.eql_v3_integer_ord'].builder('ord_int'), + ), + matchText: makeEqlV3Column( + V3_MATRIX['public.eql_v3_text_match'].builder('match_text'), + ), +} as never) + +// Tier metadata: property (drizzle) + DB column + a present-row plaintext. +const TIERS = [ + { + key: 'storageText', + db: 'storage_text', + domain: 'public.eql_v3_text', + sample: 'stored-secret', + }, + { + key: 'eqText', + db: 'eq_text', + domain: 'public.eql_v3_text_eq', + sample: 'ada@example.com', + }, + { + key: 'ordInt', + db: 'ord_int', + domain: 'public.eql_v3_integer_ord', + sample: 42, + }, + { + key: 'matchText', + db: 'match_text', + domain: 'public.eql_v3_text_match', + sample: 'ada lovelace', + }, +] as const + +const schema = extractEncryptionSchemaV3(nullableTable) + +type SelectRow = { rowKey: string } + +let client: Awaited> +let ops: ReturnType +let db: ReturnType + +function unwrap(result: { data?: T; failure?: { message: string } }): T { + if (result.failure) throw new Error(result.failure.message) + return result.data as T +} + +const columnFor = (key: string): SQL => + (nullableTable as unknown as Record)[key] + +async function selectRowKeys(condition: SQL): Promise { + const rows = (await db + .select({ rowKey: nullableTable.rowKey }) + .from(nullableTable) + .where(and(drizzleEq(nullableTable.testRunId, RUN), condition)) + .orderBy(drizzleAsc(nullableTable.rowKey))) as SelectRow[] + return rows.map((row) => row.rowKey) +} + +beforeAll(async () => { + // EQL v3 is installed once per run by `global-setup.ts`. + client = await EncryptionV3({ schemas: [schema] }) + ops = createEncryptionOperatorsV3(client) + db = drizzle({ client: sqlClient }) + + const columnDefs = TIERS.map((t) => `"${t.db}" ${t.domain}`).join(',\n ') + await sqlClient.unsafe(` + CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + row_key TEXT NOT NULL, + test_run_id TEXT NOT NULL, + ${columnDefs} + ) + `) + + // Row A: every encrypted column NULL. Row B: every column present. + const rowA: Record = { rowKey: ROW_A, testRunId: RUN } + const rowB: Record = { rowKey: ROW_B, testRunId: RUN } + for (const t of TIERS) { + rowA[t.key] = null + rowB[t.key] = t.sample + } + + const encryptedRows = unwrap>>( + await client.bulkEncryptModels([rowA, rowB] as never, schema), + ) + await db.insert(nullableTable).values(encryptedRows as never) +}, 120000) + +afterAll(async () => { + await sqlClient`DELETE FROM ${sqlClient(TABLE_NAME)} WHERE test_run_id = ${RUN}` + await sqlClient.end() +}, 30000) + +describe('v3 drizzle NULL persistence across tiers (live pg)', () => { + it.each(TIERS)('$domain isNull selects the NULL row', async (tier) => { + expect(await selectRowKeys(ops.isNull(columnFor(tier.key)))).toEqual([ + ROW_A, + ]) + }, 30000) + + it.each(TIERS)('$domain isNotNull selects the present row', async (tier) => { + expect(await selectRowKeys(ops.isNotNull(columnFor(tier.key)))).toEqual([ + ROW_B, + ]) + }, 30000) + + it.each( + TIERS, + )('$domain stores a real NULL for the null row', async (tier) => { + const [row] = await sqlClient.unsafe>( + `SELECT "${tier.db}"::jsonb AS value FROM ${TABLE_NAME} + WHERE test_run_id = $1 AND row_key = $2`, + [RUN, ROW_A], + ) + // Without this, a missing fixture makes `row.value` raise a TypeError and + // the failure reads as a null-handling bug rather than an absent row. + expect(row).toBeDefined() + expect(row.value).toBeNull() + }, 30000) + + it.each( + TIERS, + )('$domain present cell decrypts to its plaintext', async (tier) => { + const [row] = await sqlClient.unsafe>( + `SELECT "${tier.db}"::jsonb AS value FROM ${TABLE_NAME} + WHERE test_run_id = $1 AND row_key = $2`, + [RUN, ROW_B], + ) + expect(row.value).toHaveProperty('c') + const decrypted = unwrap(await client.decrypt(row.value as never)) + expect(decrypted).toBe(tier.sample) + }, 30000) +}) diff --git a/packages/stack-drizzle/integration/relational.integration.test.ts b/packages/stack-drizzle/integration/relational.integration.test.ts new file mode 100644 index 000000000..ee36fcf7f --- /dev/null +++ b/packages/stack-drizzle/integration/relational.integration.test.ts @@ -0,0 +1,652 @@ +/** + * The Drizzle v3 tests the family driver cannot express. + * + * Per-domain equality, ordering, ranges, containment and capability rejections + * moved to `families.integration.test.ts`, where they are derived from the + * catalog and shared with the Supabase adapter. What remains is everything that + * is about SQL shape rather than about a domain: + * + * - boolean combinators (`and`/`or`/`not`) over disjoint encrypted predicates + * - `exists` / `notExists` correlated subqueries + * - joins against plain tables while filtering encrypted columns + * - `limit`/`offset` pagination over an encrypted ordering + * - the free-text needle guards: a needle below `token_length` blooms to + * nothing and `stored_bf @> '{}'` holds for EVERY row, so before the guard a + * short needle silently returned the whole table + * - a statically-typed bigint round-trip + * + * EQL v3 is installed once per run by `globalSetup`, via the real + * `stash eql install`. This suite throws rather than skips when unconfigured. + */ + +import { EncryptionV3 } from '@cipherstash/stack/v3' +import { + type DomainSpec, + databaseUrl, + type EqlV3TypeName, + isCovered, + plainValue as plainValueFor, + eqlTypeSlug as slug, + sortedKeysFor as sortedKeysForKit, + typedEntries, + unwrapResult, + V3_MATRIX, +} from '@cipherstash/test-kit' +import { + and, + asc as drizzleAsc, + eq as drizzleEq, + type SQL, + type SQLWrapper, +} from 'drizzle-orm' +import { integer, pgTable, text } from 'drizzle-orm/pg-core' +import { drizzle } from 'drizzle-orm/postgres-js' +import postgres from 'postgres' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { makeEqlV3Column } from '../src/v3/column' +import { + createEncryptionOperatorsV3, + EncryptionOperatorError, + extractEncryptionSchemaV3, + types as v3drizzle, +} from '../src/v3/index.js' + +const sqlClient = postgres(databaseUrl(), { prepare: false }) + +// Per-run table suffix so two runs sharing a database (a persistent/reused CI +// database, a developer's local DB, or re-enabled file parallelism) never +// operate on the same physical table — one run's `beforeAll` DROP would +// otherwise blow away a table another run is mid-query on. Mirrors the family +// suites' run-scoped naming (`rows.ts` `planTable`). +const RID = Math.random().toString(36).slice(2, 8) +const TABLE_NAME = `protect_ci_v3_drizzle_matrix_${RID}` +const ACCOUNT_TABLE_NAME = `protect_ci_v3_drizzle_matrix_accounts_${RID}` +const RUN = `run-${Date.now()}-${RID}` +const ROW_A = 'row-a' +const ROW_B = 'row-b' +// A third row. With only two rows every predicate can return just [A], [B], +// [A,B] or [] — so an `eq` that over-matches a near-miss value is undetectable, +// and ordering can never carry a tie. Row `i` takes `samples[min(i, len-1)]` +// per domain (the scheme `v3-matrix/matrix-live-pg.test.ts` already uses), so +// domains with a third distinct sample get a near-miss row, and domains with +// only two (date, timestamp, boolean) get a deliberate ORDER BY tie with ROW_B. +const ROW_C = 'row-c' +const ROWS = [ROW_A, ROW_B, ROW_C] as const + +// Covered domains only. The `_ord_ore` rows are `deferred`: their columns cannot +// hold data on managed Postgres — the domain CHECK calls `ore_domain_unavailable` +// and the seed INSERT raises — so a table built from every row can only ever run +// against a superuser database. Filtering here is what lets this suite run on +// both the plain-Postgres and Supabase variants. +const matrixEntries = typedEntries(V3_MATRIX).filter(([, spec]) => + isCovered(spec), +) +const matrixColumns = Object.fromEntries( + matrixEntries.map(([eqlType, spec]) => [ + slug(eqlType), + makeEqlV3Column(spec.builder(slug(eqlType))), + ]), +) + +const matrixTable = pgTable(TABLE_NAME, { + id: integer('id').primaryKey().generatedAlwaysAsIdentity(), + rowKey: text('row_key').notNull(), + testRunId: text('test_run_id').notNull(), + nullableTextEq: makeEqlV3Column( + V3_MATRIX['public.eql_v3_text_eq'].builder('nullable_text_eq'), + ), + ...matrixColumns, +}) + +const accountsTable = pgTable(ACCOUNT_TABLE_NAME, { + id: integer('id').primaryKey().generatedAlwaysAsIdentity(), + rowKey: text('row_key').notNull(), + label: text('label').notNull(), + testRunId: text('test_run_id').notNull(), +}) + +// A statically-typed encrypted table (via the drizzle `types` namespace) with +// concrete bigint columns. Unlike the dynamic matrix table, its column set is +// known at compile time, so it exercises A3 end-to-end with ZERO casts: the +// insert takes envelope rows and the select yields `Encrypted` values ready for +// decrypt. +const BIGINT_TABLE_NAME = `protect_ci_v3_drizzle_bigint_${RID}` +const bigintTable = pgTable(BIGINT_TABLE_NAME, { + id: integer('id').primaryKey().generatedAlwaysAsIdentity(), + rowKey: text('row_key').notNull(), + testRunId: text('test_run_id').notNull(), + balance: v3drizzle.BigintOrd('balance'), + ledger: v3drizzle.BigintEq('ledger'), +}) + +// Full i64 bounds — proves protect-ffi 0.28 round-trips a JS bigint beyond +// Number.MAX_SAFE_INTEGER losslessly through the encrypted column. +const BIGINT_BALANCE = 9223372036854775807n +const BIGINT_LEDGER = -9223372036854775808n +// A second row the filters must exclude: a negative balance (so `gt(0n)` has +// something to reject) and a small positive ledger. +const BIGINT_B_BALANCE = -5n +const BIGINT_B_LEDGER = 100n + +const schema = extractEncryptionSchemaV3(matrixTable) +const bigintSchema = extractEncryptionSchemaV3(bigintTable) + +type PlainValue = string | number | bigint | boolean | Date +type RowKey = (typeof ROWS)[number] +type MatrixPlainRow = Record +type SelectRow = { rowKey: string } +type Db = ReturnType +type Client = Awaited> +type Ops = ReturnType +type ComparisonOperator = 'gt' | 'gte' | 'lt' | 'lte' + +let client: Client +let ops: Ops +let db: Db + +const equalityDomains = matrixEntries.filter( + ([, spec]) => spec.indexes.unique || spec.indexes.ore || spec.indexes.ope, +) +const orderDomains = matrixEntries.filter( + ([, spec]) => spec.indexes.ore || spec.indexes.ope, +) +const matchDomains = matrixEntries.filter(([, spec]) => spec.indexes.match) +const noEqualityDomains = matrixEntries.filter( + ([, spec]) => !spec.indexes.unique && !spec.indexes.ore && !spec.indexes.ope, +) +const noOrderDomains = matrixEntries.filter( + ([, spec]) => !spec.indexes.ore && !spec.indexes.ope, +) +const noMatchDomains = matrixEntries.filter(([, spec]) => !spec.indexes.match) +const comparisonOperators: Array< + [ComparisonOperator, (cmp: number) => boolean] +> = [ + ['gt', (cmp) => cmp > 0], + ['gte', (cmp) => cmp >= 0], + ['lt', (cmp) => cmp < 0], + ['lte', (cmp) => cmp <= 0], +] +const comparisonDomains = orderDomains.flatMap(([eqlType, spec]) => + comparisonOperators.map( + ([operator, predicate]) => [eqlType, spec, operator, predicate] as const, + ), +) + +const matrixColumn = (eqlType: EqlV3TypeName): SQLWrapper => + (matrixTable as unknown as Record)[slug(eqlType)] + +const scoped = (cond: SQL | undefined): SQL | undefined => + cond ? and(drizzleEq(matrixTable.testRunId, RUN), cond) : cond + +// The plaintext oracle (`plainValue`, `comparePlain`, `sortedKeysFor`) lives in +// `@cipherstash/test-kit`, so the bytewise-ordering rules have a single home. +// These wrappers just bind this suite's fixed `ROWS` set. +const plainValue = (spec: DomainSpec, rowKey: RowKey): PlainValue => + plainValueFor(spec, ROWS, rowKey) + +const sortedKeysFor = (spec: DomainSpec, direction: 'asc' | 'desc'): string[] => + sortedKeysForKit(spec, ROWS, direction) + +async function selectRowKeys(condition: SQL | undefined): Promise { + if (!condition) throw new Error('Expected query condition') + const rows = (await db + .select({ rowKey: matrixTable.rowKey }) + .from(matrixTable) + .where(scoped(condition)) + .orderBy(drizzleAsc(matrixTable.rowKey))) as SelectRow[] + return rows.map((row) => row.rowKey) +} + +function encryptedInsertRows(): MatrixPlainRow[] { + return ROWS.map((rowKey) => { + const row: MatrixPlainRow = { + rowKey, + testRunId: RUN, + nullableTextEq: rowKey === ROW_A ? null : `nullable-${rowKey}`, + } + for (const [eqlType, spec] of matrixEntries) { + row[slug(eqlType)] = plainValue(spec, rowKey) + } + return row + }) +} + +beforeAll(async () => { + client = await EncryptionV3({ schemas: [schema, bigintSchema] }) + ops = createEncryptionOperatorsV3(client) + db = drizzle({ client: sqlClient }) + + const columnDefs = matrixEntries + .map(([eqlType]) => `"${slug(eqlType)}" ${eqlType} NOT NULL`) + .join(',\n ') + + // Table names are run-scoped (see RID), so DROP IF EXISTS is normally a no-op; + // it stays as a belt-and-braces guard against an id collision. Recreating from + // scratch each run also means a catalog change can never silently reuse a + // stale schema — the bug that bit once when the `_ord_ore` domains were + // filtered out of `matrixEntries` but a leftover fixed-name table kept its nine + // ORE columns, making every INSERT raise `ore_domain_unavailable` on managed + // Postgres (the domain CHECK RAISEs even for a NULL value). + await sqlClient.unsafe(` + DROP TABLE IF EXISTS ${TABLE_NAME} + `) + await sqlClient.unsafe(` + CREATE TABLE ${TABLE_NAME} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + row_key TEXT NOT NULL, + test_run_id TEXT NOT NULL, + nullable_text_eq public.eql_v3_text_eq, + ${columnDefs} + ) + `) + await sqlClient.unsafe(` + DROP TABLE IF EXISTS ${ACCOUNT_TABLE_NAME} + `) + await sqlClient.unsafe(` + CREATE TABLE ${ACCOUNT_TABLE_NAME} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + row_key TEXT NOT NULL, + label TEXT NOT NULL, + test_run_id TEXT NOT NULL + ) + `) + await sqlClient.unsafe(` + DROP TABLE IF EXISTS ${BIGINT_TABLE_NAME} + `) + await sqlClient.unsafe(` + CREATE TABLE ${BIGINT_TABLE_NAME} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + row_key TEXT NOT NULL, + test_run_id TEXT NOT NULL, + balance public.eql_v3_bigint_ord NOT NULL, + ledger public.eql_v3_bigint_eq NOT NULL + ) + `) + + const encryptedRows = unwrapResult( + await client.bulkEncryptModels(encryptedInsertRows(), schema), + ) + await db.insert(matrixTable).values(encryptedRows) + await db.insert(accountsTable).values([ + { rowKey: ROW_A, label: 'primary', testRunId: RUN }, + { rowKey: ROW_B, label: 'secondary', testRunId: RUN }, + ]) + + // A3 end-to-end, cast-free: encrypt a native bigint model, insert the + // resulting envelope rows (typed against the column's `Encrypted` data slot), + // no `as never` anywhere. + // + // ROW_B exists so the filter proofs below have a row they must EXCLUDE. On a + // one-row table `gt(balance, 0n)` returning every row is indistinguishable + // from it returning the right row. + const bigintRows = unwrapResult( + await client.bulkEncryptModels( + [ + { + rowKey: ROW_A, + testRunId: RUN, + balance: BIGINT_BALANCE, + ledger: BIGINT_LEDGER, + }, + { + rowKey: ROW_B, + testRunId: RUN, + balance: BIGINT_B_BALANCE, + ledger: BIGINT_B_LEDGER, + }, + ], + bigintSchema, + ), + ) + await db.insert(bigintTable).values(bigintRows) +}, 120000) + +afterAll(async () => { + // Tables are run-scoped, so drop them outright rather than DELETE-ing rows — + // no other run shares them, and this leaves nothing behind on a persistent DB. + await sqlClient.unsafe(`DROP TABLE IF EXISTS ${TABLE_NAME}`) + await sqlClient.unsafe(`DROP TABLE IF EXISTS ${ACCOUNT_TABLE_NAME}`) + await sqlClient.unsafe(`DROP TABLE IF EXISTS ${BIGINT_TABLE_NAME}`) + await sqlClient.end() +}, 30000) + +describe('v3 drizzle — relational, needle guards, pagination', () => { + // A needle below the tokenizer's `token_length` builds an EMPTY bloom filter, + // and `stored_bf @> '{}'` holds for every row — so before the SDK guard this + // silently returned the whole table. + // + // `'👍👍'` is the regression case: 4 UTF-16 code units but only 2 codepoints, + // so a `needle.length` floor waved it through and it matched every row. The + // tokenizer counts codepoints. `''` tokenizes to nothing under any tokenizer. + it.each( + matchDomains.flatMap(([eqlType]) => + ['ad', '👍👍', ''].map((needle) => [eqlType, needle] as const), + ), + )( + '%s matches rejects the unanswerable needle %j before encrypting', + async (eqlType, needle) => { + const attempt = ops.matches(matrixColumn(eqlType), needle) + await expect(attempt).rejects.toBeInstanceOf(EncryptionOperatorError) + // Assert the GUARD rejected it, not the encryption layer. + // `operandFailure` also throws `EncryptionOperatorError`, so matching only + // the class would let an encryption error stand in for the guard and the + // test would pass for the wrong reason. + await expect(attempt).rejects.toThrow(/free-text search needs/) + }, + 30000, + ) + + // The complement: a needle that DOES reach the floor in codepoints must be + // ANSWERED, not over-rejected — otherwise the fix for the astral fail-open + // would just over-correct into rejecting usable needles. + // + // Restricted to match-ONLY columns: a column that also carries an `ore` index + // (`text_search`) cannot encrypt a non-ASCII operand at all — the ORE term + // raises "Can only order strings that are pure ASCII" — so a non-ASCII needle + // there fails inside encryption, long after the guard has passed it. That + // constraint is pinned by its own test below rather than silently conflated + // with the codepoint floor. + // + // Escapes, not literals: the precomposed NFC form of `ee-with-accents` is only + // 2 codepoints and IS rejected, so a bare literal would test the opposite case + // depending on the file's on-disk normalisation. + const NFD_EE = 'e\u0301e\u0301' // 4 codepoints, 2 grapheme clusters + const matchOnlyDomains = matchDomains.filter( + ([, spec]) => !spec.indexes.ore && !spec.indexes.ope, + ) + + it.each( + matchOnlyDomains.flatMap(([eqlType]) => + ['\u{1F44D}\u{1F44D}\u{1F44D}', NFD_EE].map( + (needle) => [eqlType, needle] as const, + ), + ), + )( + '%s matches answers the codepoint-sufficient needle %j with no match', + async (eqlType, needle) => { + const rows = await selectRowKeys( + await ops.matches(matrixColumn(eqlType), needle), + ) + expect(rows).toEqual([]) + + // The control. An over-rejecting guard would have thrown above, and a + // fail-open `contains` would have returned every row — but a + // constant-false `contains` also returns [], and nothing above catches + // it. Prove the same column still answers a needle that IS present. + const present = await selectRowKeys( + await ops.matches(matrixColumn(eqlType), 'ada'), + ) + expect(present.length).toBeGreaterThan(0) + }, + 30000, + ) + + // The non-ASCII ORE-needle test that used to live here drove + // `matchDomains.filter(([, spec]) => spec.indexes.ore)`. Since the eql-3.0.0 + // OPE re-pin, NO match domain carries an `ore` index — `text_search` is + // `unique + ope + match`, `text_match` is `match` — so that `it.each` had zero + // cases and reported nothing. A vacuous test reads exactly like a passing one. + // + // Assert the state instead. If an ORE-flavoured match domain ever returns, this + // fails and whoever adds it has to restore the needle test with it. + it('no match domain carries an ORE index, so no ASCII-only needle rule applies', () => { + const oreMatchDomains = matchDomains.filter(([, spec]) => spec.indexes.ore) + + expect(oreMatchDomains.map(([eqlType]) => eqlType)).toEqual([]) + }) + + // The two predicates must be satisfied by DISJOINT row sets, or `and` and + // `or` return the same thing and the test cannot tell them apart. The old + // pairing (`text_eq = 'ada@example.com'` AND `integer_ord < 0`) was true for + // ROW_B alone under both operators, so swapping `and` for `or` still passed. + // text_eq = 'ada@example.com' -> ROW_B only + // integer_ord >= 0 -> ROW_A (0) and ROW_C (2147483647), not ROW_B (-42) + const disjointPredicates = () => + [ + ops.eq(matrixColumn('public.eql_v3_text_eq'), 'ada@example.com'), + ops.gte(matrixColumn('public.eql_v3_integer_ord'), 0), + ] as const + + // Two assertions, one block, deliberately. The disjoint pair proves `and` is + // not `or`: swapping the operator turns [] into [A,B,C]. But [] is also what + // a constant-false `and` returns, and `beforeAll` cannot catch that — it only + // catches a failed seed. The intersecting pair is the control that can: it + // must return its row, so it dies on a constant-false `and` and on an eq/lt + // term that silently matches nothing. Keeping it in a sibling `it` would not + // couple them, since vitest runs on past a failure and the sibling could go + // red while this stayed green. + // text_eq = 'ada@example.com' -> ROW_B only + // integer_ord >= 0 -> ROW_A (0), ROW_C (2147483647), not ROW_B (-42) + // integer_ord < 0 -> ROW_B (-42) only + it('and requires both encrypted predicates, unlike or', async () => { + expect(await selectRowKeys(await ops.and(...disjointPredicates()))).toEqual( + [], + ) + + const intersecting = await selectRowKeys( + await ops.and( + ops.eq(matrixColumn('public.eql_v3_text_eq'), 'ada@example.com'), + ops.lt(matrixColumn('public.eql_v3_integer_ord'), 0), + ), + ) + expect(intersecting).toEqual([ROW_B]) + }, 30000) + + it('or requires either encrypted predicate, unlike and', async () => { + const rows = await selectRowKeys(await ops.or(...disjointPredicates())) + expect(rows).toEqual([ROW_A, ROW_B, ROW_C]) + }, 30000) + + it('or combines encrypted predicates', async () => { + const rows = await selectRowKeys( + await ops.or( + ops.eq(matrixColumn('public.eql_v3_text_eq'), ''), + ops.eq(matrixColumn('public.eql_v3_text_eq'), 'ada@example.com'), + ), + ) + expect(rows).toEqual([ROW_A, ROW_B]) + }, 30000) + + it('not negates an encrypted predicate', async () => { + const rows = await selectRowKeys( + ops.not(await ops.eq(matrixColumn('public.eql_v3_text_eq'), '')), + ) + expect(rows).toEqual([ROW_B, ROW_C]) + }, 30000) + + it('not(between()) negates the whole range, not just the lower bound', async () => { + // integer_ord: ROW_A=0, ROW_B=-42, ROW_C=2147483647. `not(between(0, 0))` + // must return every row whose value != 0 → ROW_B and ROW_C. + // + // `between` emits a TWO-clause conjunction, and Drizzle's passthrough `not` + // renders a bare `NOT `. Postgres binds NOT tighter than AND, so this + // only works because `v3Dialect.range` already parenthesises `(gte AND lte)`. + // Without those parens, `NOT gte(0) AND lte(0)` parses as + // `value < 0 AND value <= 0` = `value < 0` = ROW_B alone, silently dropping + // ROW_C. Asserting ROW_C is present is what discriminates the two — a + // single-bound complement would satisfy the buggy form too. + const rows = await selectRowKeys( + ops.not( + await ops.between(matrixColumn('public.eql_v3_integer_ord'), 0, 0), + ), + ) + expect(rows).toEqual([ROW_B, ROW_C]) + }, 30000) + + it('isNull and isNotNull work on nullable encrypted columns', async () => { + expect(await selectRowKeys(ops.isNull(matrixTable.nullableTextEq))).toEqual( + [ROW_A], + ) + expect( + await selectRowKeys(ops.isNotNull(matrixTable.nullableTextEq)), + ).toEqual([ROW_B, ROW_C]) + }, 30000) + + it('exists and notExists work with correlated subqueries', async () => { + const primaryAccount = db + .select({ id: accountsTable.id }) + .from(accountsTable) + .where( + and( + drizzleEq(accountsTable.testRunId, RUN), + drizzleEq(accountsTable.rowKey, matrixTable.rowKey), + drizzleEq(accountsTable.label, 'primary'), + ), + ) + const missingAccount = db + .select({ id: accountsTable.id }) + .from(accountsTable) + .where( + and( + drizzleEq(accountsTable.testRunId, RUN), + drizzleEq(accountsTable.rowKey, matrixTable.rowKey), + drizzleEq(accountsTable.label, 'missing'), + ), + ) + + expect(await selectRowKeys(ops.exists(primaryAccount))).toEqual([ROW_A]) + // ROW_C has no account row at all, so it too has no 'missing' account. + expect(await selectRowKeys(ops.notExists(missingAccount))).toEqual([ + ROW_A, + ROW_B, + ROW_C, + ]) + }, 30000) + + it('joins plain tables while filtering encrypted columns', async () => { + const rows = (await db + .select({ rowKey: matrixTable.rowKey }) + .from(matrixTable) + .innerJoin( + accountsTable, + and( + drizzleEq(accountsTable.testRunId, RUN), + drizzleEq(accountsTable.rowKey, matrixTable.rowKey), + ), + ) + .where( + scoped( + await ops.eq( + matrixColumn('public.eql_v3_text_eq'), + 'ada@example.com', + ), + ), + )) as SelectRow[] + expect(rows.map((row) => row.rowKey)).toEqual([ROW_B]) + }, 30000) + + it('paginates encrypted ordering results with limit and offset', async () => { + const spec = V3_MATRIX['public.eql_v3_integer_ord'] + const rows = (await db + .select({ rowKey: matrixTable.rowKey }) + .from(matrixTable) + .where(drizzleEq(matrixTable.testRunId, RUN)) + .orderBy(ops.asc(matrixColumn('public.eql_v3_integer_ord'))) + .limit(1) + .offset(1)) as SelectRow[] + expect(rows.map((row) => row.rowKey)).toEqual( + sortedKeysFor(spec, 'asc').slice(1, 2), + ) + }, 30000) + + // A real `TypedEncryptionClient` exposes `bulkEncrypt`, so these lists are + // encrypted in one FFI crossing and the returned terms must line up + // index-for-index with the values. Five values also crosses the + // MAX_IN_ARRAY_CONCURRENCY=4 boundary of the single-encrypt fallback that a + // `bulkEncrypt`-less client would take. Either way the OR/AND of eq/ne terms + // must be correct — a misaligned bulk response would silently select the + // wrong rows here. + it('inArray encrypts a >4-value list in one bulk crossing', async () => { + const rows = await selectRowKeys( + await ops.inArray(matrixColumn('public.eql_v3_text_eq'), [ + 'ada@example.com', + '', + 'nobody-1@example.com', + 'nobody-2@example.com', + 'nobody-3@example.com', + ]), + ) + // '' -> ROW_A, 'ada@example.com' -> ROW_B; the three "nobody" terms match + // nothing, exercising the pool without changing the expected set. ROW_C + // ('Ada Lovelace') is listed by neither and must be excluded. + expect(rows).toEqual([ROW_A, ROW_B]) + }, 30000) + + it('notInArray encrypts a >4-value list in one bulk crossing', async () => { + const rows = await selectRowKeys( + await ops.notInArray(matrixColumn('public.eql_v3_text_eq'), [ + '', + 'nobody-1@example.com', + 'nobody-2@example.com', + 'nobody-3@example.com', + 'nobody-4@example.com', + ]), + ) + // Only '' is excluded (ROW_A); ROW_B ('ada@example.com') and ROW_C + // ('Ada Lovelace') survive. + expect(rows).toEqual([ROW_B, ROW_C]) + }, 30000) + + // A3 + bigint lock: a statically-typed bigint table round-trips a real i64 + // value through encrypt → insert → select → decrypt with no casts. The select + // yields `Encrypted`-typed columns (the envelope), fed straight to decrypt. + it('round-trips a native bigint through a statically-typed encrypted column', async () => { + const encrypted = await db + .select({ balance: bigintTable.balance, ledger: bigintTable.ledger }) + .from(bigintTable) + .where( + and( + drizzleEq(bigintTable.testRunId, RUN), + drizzleEq(bigintTable.rowKey, ROW_A), + ), + ) + expect(encrypted).toHaveLength(1) + + const decrypted = unwrapResult( + await client.decryptModel(encrypted[0], bigintSchema), + ) + expect(decrypted.balance).toBe(BIGINT_BALANCE) + expect(decrypted.ledger).toBe(BIGINT_LEDGER) + }, 30000) + + // Each assertion below names a row that must be EXCLUDED. Against the former + // one-row table an operator matching everything passed all of these. + const bigintRowKeys = async (condition: SQL): Promise => { + const rows = (await db + .select({ rowKey: bigintTable.rowKey }) + .from(bigintTable) + .where(and(drizzleEq(bigintTable.testRunId, RUN), condition)) + .orderBy(drizzleAsc(bigintTable.rowKey))) as SelectRow[] + return rows.map((row) => row.rowKey) + } + + it('filters a bigint column by encrypted equality, excluding the other row', async () => { + expect( + await bigintRowKeys(await ops.eq(bigintTable.ledger, BIGINT_LEDGER)), + ).toEqual([ROW_A]) + expect( + await bigintRowKeys(await ops.eq(bigintTable.ledger, BIGINT_B_LEDGER)), + ).toEqual([ROW_B]) + // i64::MIN and 100n are both representable; a needle matching neither row + // must return nothing rather than everything. + expect(await bigintRowKeys(await ops.eq(bigintTable.ledger, 7n))).toEqual( + [], + ) + }, 30000) + + it('filters a bigint column by encrypted ordering across zero', async () => { + // ROW_B's balance is -5n, so `> 0n` must reject it. + expect(await bigintRowKeys(await ops.gt(bigintTable.balance, 0n))).toEqual([ + ROW_A, + ]) + expect(await bigintRowKeys(await ops.lt(bigintTable.balance, 0n))).toEqual([ + ROW_B, + ]) + // Range up to i64::MAX inclusive: ROW_A sits exactly on the upper bound. + expect( + await bigintRowKeys( + await ops.between(bigintTable.balance, 0n, BIGINT_BALANCE), + ), + ).toEqual([ROW_A]) + }, 30000) +}) diff --git a/packages/stack-drizzle/integration/vitest.config.ts b/packages/stack-drizzle/integration/vitest.config.ts new file mode 100644 index 000000000..b5f6762dc --- /dev/null +++ b/packages/stack-drizzle/integration/vitest.config.ts @@ -0,0 +1,22 @@ +import { resolve } from 'node:path' +import { defineConfig } from 'vitest/config' +import { sharedAlias, stackSourceAlias } from '../../../vitest.shared' +import { + integrationHarness, + integrationTestDefaults, +} from '../../test-kit/src/integration/config' + +/** + * Integration suites for the drizzle adapter: real ZeroKMS + real Postgres + * (+ PostgREST for supabase). Runs only under `test:integration` (its own CI + * job). Harness + shared `test.*` knobs come from `@cipherstash/test-kit`. + */ +export default defineConfig({ + resolve: { alias: { ...sharedAlias, ...stackSourceAlias } }, + test: { + root: resolve(__dirname, '..'), + include: ['integration/**/*.integration.test.ts'], + ...integrationHarness, + ...integrationTestDefaults, + }, +}) diff --git a/packages/stack-drizzle/package.json b/packages/stack-drizzle/package.json new file mode 100644 index 000000000..540ce71da --- /dev/null +++ b/packages/stack-drizzle/package.json @@ -0,0 +1,98 @@ +{ + "name": "@cipherstash/stack-drizzle", + "version": "0.0.0", + "description": "CipherStash Stack Drizzle ORM integration: searchable, application-layer field-level encryption for PostgreSQL.", + "keywords": [ + "encrypted", + "encryption", + "searchable-encryption", + "security", + "drizzle", + "orm", + "postgres", + "cipherstash", + "stack" + ], + "bugs": { + "url": "https://github.com/cipherstash/stack/issues" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/cipherstash/stack.git", + "directory": "packages/stack-drizzle" + }, + "license": "MIT", + "author": "CipherStash ", + "type": "module", + "main": "./dist/index.cjs", + "module": "./dist/index.js", + "types": "./dist/index.d.ts", + "sideEffects": false, + "files": [ + "dist", + "README.md" + ], + "exports": { + ".": { + "import": { + "types": "./dist/index.d.ts", + "default": "./dist/index.js" + }, + "require": { + "types": "./dist/index.d.cts", + "default": "./dist/index.cjs" + } + }, + "./v3": { + "import": { + "types": "./dist/v3/index.d.ts", + "default": "./dist/v3/index.js" + }, + "require": { + "types": "./dist/v3/index.d.cts", + "default": "./dist/v3/index.cjs" + } + }, + "./package.json": "./package.json" + }, + "typesVersions": { + "*": { + "v3": [ + "./dist/v3/index.d.ts" + ] + } + }, + "scripts": { + "prebuild": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"", + "build": "tsup", + "dev": "tsup --watch", + "test": "vitest run", + "test:types": "vitest --run --typecheck.only", + "test:integration": "vitest run --config integration/vitest.config.ts", + "analyze:complexity": "fta src --score-cap 89" + }, + "dependencies": { + "@cipherstash/stack": "workspace:*", + "@byteslice/result": "0.2.0" + }, + "peerDependencies": { + "drizzle-orm": ">=0.33" + }, + "devDependencies": { + "@cipherstash/protect-ffi": "0.29.0", + "@cipherstash/test-kit": "workspace:*", + "fta-cli": "3.0.0", + "dotenv": "17.4.2", + "drizzle-orm": "^0.45.2", + "postgres": "^3.4.8", + "tsup": "catalog:repo", + "typescript": "catalog:repo", + "vitest": "catalog:repo" + }, + "publishConfig": { + "access": "public" + }, + "engines": { + "node": ">=22" + } +} diff --git a/packages/stack/src/drizzle/index.ts b/packages/stack-drizzle/src/index.ts similarity index 98% rename from packages/stack/src/drizzle/index.ts rename to packages/stack-drizzle/src/index.ts index 6284e45b3..ff3f12bb0 100644 --- a/packages/stack/src/drizzle/index.ts +++ b/packages/stack-drizzle/src/index.ts @@ -1,5 +1,9 @@ +import type { + CastAs, + MatchIndexOpts, + TokenFilter, +} from '@cipherstash/stack/schema' import { customType } from 'drizzle-orm/pg-core' -import type { CastAs, MatchIndexOpts, TokenFilter } from '@/schema' export type { CastAs, MatchIndexOpts, TokenFilter } @@ -81,7 +85,7 @@ const columnConfigMap = new Map< * * ```typescript * import { pgTable, integer, timestamp } from 'drizzle-orm/pg-core' - * import { encryptedType } from '@cipherstash/stack/drizzle' + * import { encryptedType } from '@cipherstash/stack-drizzle' * * const users = pgTable('users', { * email: encryptedType('email', { diff --git a/packages/stack/src/drizzle/operators.ts b/packages/stack-drizzle/src/operators.ts similarity index 98% rename from packages/stack/src/drizzle/operators.ts rename to packages/stack-drizzle/src/operators.ts index 0644d7de3..674bb3ba3 100644 --- a/packages/stack/src/drizzle/operators.ts +++ b/packages/stack-drizzle/src/operators.ts @@ -1,3 +1,10 @@ +import type { EncryptionClient } from '@cipherstash/stack/encryption' +import type { + EncryptedColumn, + EncryptedTable, + EncryptedTableColumn, +} from '@cipherstash/stack/schema' +import { type QueryTypeName, queryTypes } from '@cipherstash/stack/types' import { and, arrayContained, @@ -30,13 +37,6 @@ import { sql, } from 'drizzle-orm' import type { PgTable } from 'drizzle-orm/pg-core' -import type { EncryptionClient } from '@/encryption/index.js' -import type { - EncryptedColumn, - EncryptedTable, - EncryptedTableColumn, -} from '@/schema' -import { type QueryTypeName, queryTypes } from '@/types' import type { EncryptedColumnConfig } from './index.js' import { getEncryptedColumnConfig } from './index.js' import { extractEncryptionSchema } from './schema-extraction.js' @@ -238,11 +238,20 @@ function getColumnInfo( /** * Helper to convert a value to plaintext format */ -function toPlaintext(value: unknown): string | number { +function toPlaintext(value: unknown): string | number | bigint { if (typeof value === 'boolean') { return value ? 1 : 0 } - if (typeof value === 'string' || typeof value === 'number') { + if ( + typeof value === 'string' || + typeof value === 'number' || + // `bigint` (int8 columns) must pass through as a native bigint, NOT via the + // `String(value)` fallthrough below — a stringified bigint would be + // encrypted as text and silently mismatch the column's bigint domain. The + // downstream `encryptQuery` term type is `Plaintext`, which carries bigint, + // and protect-ffi 0.28 i64-bounds-checks it at the boundary. + typeof value === 'bigint' + ) { return value } if (value instanceof Date) { @@ -255,7 +264,7 @@ function toPlaintext(value: unknown): string | number { * Value to encrypt with its associated column */ interface ValueToEncrypt { - readonly value: string | number + readonly value: string | number | bigint readonly column: SQLWrapper readonly columnInfo: ColumnInfo readonly queryType?: QueryTypeName @@ -320,7 +329,7 @@ async function encryptValues( table: EncryptedTable columnName: string values: Array<{ - value: string | number + value: string | number | bigint index: number queryType?: QueryTypeName }> diff --git a/packages/stack/src/drizzle/schema-extraction.ts b/packages/stack-drizzle/src/schema-extraction.ts similarity index 99% rename from packages/stack/src/drizzle/schema-extraction.ts rename to packages/stack-drizzle/src/schema-extraction.ts index 824234148..90bb3ec1e 100644 --- a/packages/stack/src/drizzle/schema-extraction.ts +++ b/packages/stack-drizzle/src/schema-extraction.ts @@ -1,10 +1,10 @@ -import type { PgCustomColumn, PgTable } from 'drizzle-orm/pg-core' import { type EncryptedColumn, type EncryptedTable, encryptedColumn, encryptedTable, -} from '@/schema' +} from '@cipherstash/stack/schema' +import type { PgCustomColumn, PgTable } from 'drizzle-orm/pg-core' import { getEncryptedColumnConfig } from './index.js' /** diff --git a/packages/stack-drizzle/src/v3/codec.ts b/packages/stack-drizzle/src/v3/codec.ts new file mode 100644 index 000000000..07c822ee9 --- /dev/null +++ b/packages/stack-drizzle/src/v3/codec.ts @@ -0,0 +1,100 @@ +/** + * Codec for the value actually stored in a v3 column: the ENCRYPTED EQL v3 + * envelope ({@link Encrypted}), not plaintext. v3 columns are + * `CREATE DOMAIN ... AS jsonb`, so the envelope serialises as plain jsonb — + * distinct from v2's composite-literal parser. + */ + +import type { Encrypted } from '@cipherstash/stack/types' + +/** Thrown when a driver value cannot be read back as an EQL v3 envelope. */ +export class EqlV3CodecError extends Error { + constructor(message: string, options?: ErrorOptions) { + super(message, options) + this.name = 'EqlV3CodecError' + } +} + +/** + * A stored EQL envelope always carries a schema version (`v`) and a ciphertext: + * at `c` on scalar payloads, or at `sv[0].c` on a SteVec document (`k: "sv"`), + * which has no top-level `c`. Checking `v` plus either carrier distinguishes an + * envelope from a bare scalar, an array, or an unrelated object — without + * paying a full structural validation on every decrypted row. + * + * The `sv` carrier must be a non-empty array: `sv[0]` is the decryption root, + * so `sv: []` has a ciphertext key but no ciphertext, and would reach `decrypt` + * as garbage. + */ +function assertEnvelope(value: unknown, source: string): Encrypted { + if (typeof value !== 'object' || value === null || Array.isArray(value)) { + throw new EqlV3CodecError( + `Expected an EQL encrypted envelope from ${source}, got ${Array.isArray(value) ? 'an array' : typeof value}. The column may not hold EQL data.`, + ) + } + const envelope = value as { v?: unknown; c?: unknown; sv?: unknown } + // A SteVec carries its root ciphertext at `sv[0].c`, so an empty or non-array + // `sv` carries no ciphertext at all — presence of the key is not enough. + const hasSteVec = Array.isArray(envelope.sv) && envelope.sv.length > 0 + const missing = + envelope.v === undefined + ? '"v"' + : envelope.c === undefined && !hasSteVec + ? 'a ciphertext ("c", or a non-empty "sv" for a SteVec document)' + : undefined + if (missing) { + throw new EqlV3CodecError( + `Expected an EQL encrypted envelope from ${source}, but it is missing ${missing}. The column may not hold EQL data.`, + ) + } + return value as Encrypted +} + +/** + * `JSON.stringify` replacer that renders any stray `bigint` as its decimal + * string instead of throwing `TypeError: Do not know how to serialize a + * BigInt`. A well-formed EQL v3 envelope never carries a `bigint` — `bigint` + * plaintext is encrypted to ciphertext strings before it ever reaches this + * codec — so this is a defensive guard against a malformed envelope, never a + * data path. + */ +function bigintSafeReplacer(_key: string, value: unknown): unknown { + return typeof value === 'bigint' ? value.toString() : value +} + +/** Serialise an encrypted envelope to a jsonb string for the driver. Null and + * undefined map to SQL NULL (JS `null`), never the JSON `null` literal. */ +export function v3ToDriver(value: Encrypted | null | undefined): string | null { + if (value === null || value === undefined) { + return null + } + return JSON.stringify(value, bigintSafeReplacer) +} + +/** Parse a driver jsonb value back into an encrypted envelope. `postgres` + * hands back an already-parsed object for jsonb; a string is parsed. Null and + * undefined normalise to `null` (SQL NULL). + * + * Malformed and non-envelope payloads throw {@link EqlV3CodecError} rather than + * surfacing a raw `SyntaxError` or passing a bare scalar through as though it + * were an envelope — a wrong value here reaches `decrypt` as garbage. */ +export function v3FromDriver( + value: string | object | null | undefined, +): Encrypted | null { + if (value === null || value === undefined) { + return null + } + if (typeof value === 'object') { + return assertEnvelope(value, 'the driver') + } + let parsed: unknown + try { + parsed = JSON.parse(value) + } catch (cause) { + throw new EqlV3CodecError( + `Failed to parse an EQL v3 encrypted envelope from the driver: ${cause instanceof Error ? cause.message : String(cause)}`, + { cause }, + ) + } + return assertEnvelope(parsed, 'the driver') +} diff --git a/packages/stack-drizzle/src/v3/column.ts b/packages/stack-drizzle/src/v3/column.ts new file mode 100644 index 000000000..3c2d184a1 --- /dev/null +++ b/packages/stack-drizzle/src/v3/column.ts @@ -0,0 +1,124 @@ +import { + type AnyEncryptedV3Column, + types as v3Types, +} from '@cipherstash/stack/eql/v3' +import type { Encrypted } from '@cipherstash/stack/types' +import { customType } from 'drizzle-orm/pg-core' +import { v3FromDriver, v3ToDriver } from './codec.js' + +const buildersByDomain: ReadonlyMap< + string, + (name: string) => AnyEncryptedV3Column +> = new Map( + Object.values(v3Types).map((factory) => [ + factory('__probe__').getEqlType(), + factory, + ]), +) + +/** Every concrete `public.` string, derived from the eql/v3 factories. */ +export const EQL_V3_DOMAINS: ReadonlySet = new Set( + buildersByDomain.keys(), +) + +/** + * Drizzle passes `config.customTypeParams` from the builder into the processed + * PgColumn by reference — it is never cloned or serialized — so a `Symbol.for` + * key survives the whole builder→column path. Stashing the v3 builder there + * keeps recovery tied to the concrete column instance instead of a + * module-global name lookup. `Symbol.for` is registry-global, so a CJS/ESM + * duality of this module still resolves the same key. + */ +const EQL_V3_COLUMN_PARAM = Symbol.for('cipherstash:eqlv3Column') + +type EqlV3ColumnCarrier = Record + +function readBuilder( + carrier: EqlV3ColumnCarrier | undefined, +): AnyEncryptedV3Column | undefined { + return carrier?.[EQL_V3_COLUMN_PARAM] as AnyEncryptedV3Column | undefined +} + +function writeBuilder( + carrier: EqlV3ColumnCarrier | undefined, + builder: AnyEncryptedV3Column, +): void { + if (!carrier) return + carrier[EQL_V3_COLUMN_PARAM] = builder +} + +function getCarrier(column: unknown): EqlV3ColumnCarrier | undefined { + if (!column || typeof column !== 'object') return undefined + + const direct = column as EqlV3ColumnCarrier + if (readBuilder(direct)) return direct + + const maybeWithConfig = column as { + config?: { customTypeParams?: EqlV3ColumnCarrier } + } + return maybeWithConfig.config?.customTypeParams +} + +function getSqlType(column: unknown): string | undefined { + if (!column || typeof column !== 'object') return undefined + const columnAny = column as { + getSQLType?: () => unknown + dataType?: unknown + sqlName?: unknown + } + const sqlType = + typeof columnAny.getSQLType === 'function' + ? columnAny.getSQLType() + : undefined + if (typeof sqlType === 'string') return sqlType + const dt = columnAny.dataType + const domain = typeof dt === 'function' ? dt() : (columnAny.sqlName ?? dt) + return typeof domain === 'string' ? domain : undefined +} + +export function makeEqlV3Column(builder: C) { + const domain = builder.getEqlType() + const name = builder.getName() + + // What is stored/inserted/selected is the ENCRYPTED EQL v3 jsonb envelope + // (produced by `client.encrypt` / `bulkEncryptModels`), NOT the column's + // plaintext. So `data` is the envelope type — an insert takes an already- + // encrypted `Encrypted`, and a select yields one, ready for `decryptModel`. + const column = customType<{ data: Encrypted; driverData: string | null }>({ + dataType() { + return domain + }, + toDriver(value: Encrypted): string | null { + return v3ToDriver(value) + }, + fromDriver(value: string | object | null | undefined): Encrypted { + // A present jsonb value round-trips to an envelope; the driver only + // reaches here for non-null values, so the SQL-NULL branch is a safety + // net rather than a live path (the boundary cast covers it). + return v3FromDriver(value) as Encrypted + }, + })(name) + + writeBuilder(getCarrier(column), builder) + writeBuilder(column as unknown as EqlV3ColumnCarrier, builder) + return column +} + +export function getEqlV3Column( + columnName: string, + column: unknown, +): AnyEncryptedV3Column | undefined { + const stashed = readBuilder(getCarrier(column)) + if (stashed) return stashed + + const sqlType = getSqlType(column) + const builderFactory = sqlType ? buildersByDomain.get(sqlType) : undefined + return builderFactory?.(columnName) +} + +export function isEqlV3Column(column: unknown): boolean { + if (!column || typeof column !== 'object') return false + if (readBuilder(getCarrier(column))) return true + const sqlType = getSqlType(column) + return typeof sqlType === 'string' && EQL_V3_DOMAINS.has(sqlType) +} diff --git a/packages/stack-drizzle/src/v3/index.ts b/packages/stack-drizzle/src/v3/index.ts new file mode 100644 index 000000000..7c0426d4c --- /dev/null +++ b/packages/stack-drizzle/src/v3/index.ts @@ -0,0 +1,8 @@ +export { EqlV3CodecError, v3FromDriver, v3ToDriver } from './codec.js' +export { getEqlV3Column, isEqlV3Column, makeEqlV3Column } from './column.js' +export { + createEncryptionOperatorsV3, + EncryptionOperatorError, +} from './operators.js' +export { extractEncryptionSchemaV3 } from './schema-extraction.js' +export { types } from './types.js' diff --git a/packages/stack-drizzle/src/v3/operators.ts b/packages/stack-drizzle/src/v3/operators.ts new file mode 100644 index 000000000..e8105202d --- /dev/null +++ b/packages/stack-drizzle/src/v3/operators.ts @@ -0,0 +1,725 @@ +import type { Result } from '@byteslice/result' +import type { AuditConfig } from '@cipherstash/stack/adapter-kit' +import { + matchNeedleError, + stripDomainSchema, +} from '@cipherstash/stack/adapter-kit' +import type { + AnyEncryptedV3Column, + AnyV3Table, +} from '@cipherstash/stack/eql/v3' +import type { EncryptionError } from '@cipherstash/stack/errors' +import type { LockContext } from '@cipherstash/stack/identity' +import type { ColumnSchema } from '@cipherstash/stack/schema' +import type { + EncryptedQueryResult, + QueryTypeName, +} from '@cipherstash/stack/types' +import { + and, + asc, + Column, + desc, + exists, + is, + isNotNull, + isNull, + not, + notExists, + or, + type SQL, + type SQLWrapper, + sql, +} from 'drizzle-orm' +import type { PgTable } from 'drizzle-orm/pg-core' +import { getEqlV3Column } from './column.js' +import { + extractEncryptionSchemaV3, + getDrizzleTableName, +} from './schema-extraction.js' +import { type ComparisonOp, type EqualityOp, v3Dialect } from './sql-dialect.js' + +/** + * The client capability this factory consumes: `encryptQuery`, in both its + * single (`value, opts`) and batch (`terms[]`) forms. Declared structurally — + * with maximally-permissive operands — so it is satisfied by the nominal + * `EncryptionClient`, by the `TypedEncryptionClient` that `EncryptionV3` returns + * (whatever its schema tuple), AND by a hand-rolled test double, none needing a + * cast. Typing the parameter to the nominal `TypedEncryptionClient` would + * reject a client built for a narrower schema tuple (it accepts fewer tables than + * `readonly AnyV3Table[]`); the structural surface sidesteps that variance. + * + * Every operand is a QUERY TERM, not a storage envelope: `encryptQuery` mints a + * ciphertext-free term (no `c`) carrying all of the column's configured index + * terms, which the operator layer casts to the column's `eql_v3.query_` + * type. This reaches the bundle's `(domain, query_)` overloads and keeps + * WHERE-clause payloads free of the ciphertext a query never needs (#622). + * + * `never` operands: the real client's `encryptQuery` is generic (`queryType` is + * constrained to the column's own query types), which a concrete signature here + * cannot match. `never` params keep the structural surface satisfiable by that + * generic method AND by a test double; the call sites cast their real operands. + */ +type OperandEncryptionClient = { + encryptQuery( + value: never, + opts: never, + ): ChainableOperation + encryptQuery(terms: never): ChainableOperation +} + +/** + * A dedicated error for v3 operator gating and operand-encryption failures, + * carrying the offending column/table/operator for diagnostics. + * + * INTENTIONAL FORK: this mirrors the v2 adapter's `EncryptionOperatorError` + * rather than sharing it. Unifying the two would couple `./drizzle` and + * `./eql/v3/drizzle` — two independently-versioned public entry points — so the + * duplication is deliberate, not an oversight. + */ +export class EncryptionOperatorError extends Error { + constructor( + message: string, + public readonly context?: { + columnName?: string + tableName?: string + operator?: string + }, + ) { + super(message) + this.name = 'EncryptionOperatorError' + } +} + +interface ColumnContext { + builder: AnyEncryptedV3Column + table: AnyV3Table + indexes: ColumnSchema['indexes'] + columnName: string + tableName: string + /** The `eql_v3.query_` type an operand for this column casts to, so + * `encryptQuery`'s ciphertext-free term reaches the narrowed-query overloads. + * `null` for storage-only columns (no query domain); those never encrypt an + * operand — every operator gates on a query capability first. JSON columns + * override this at the call site (`query_jsonb`, an irregular name). */ + queryCast: string | null +} + +/** + * The `eql_v3.query_` cast for a column's storage domain — e.g. + * `public.eql_v3_text_search` → `eql_v3.query_text_search`. Uniform across the + * queryable column domains (`_eq`, `_ord`, `_ord_ore`, `_match`, `_search`); the + * two irregular cases are handled elsewhere: storage-only domains + * (`eql_v3_boolean`, the bare base types) have no query domain and return `null` + * (they are never queried), and `eql_v3_json` maps to `query_jsonb`, cast + * explicitly on the JSON path. + */ +function queryCastForDomain(eqlType: string): string | null { + const bare = stripDomainSchema(eqlType) // public.eql_v3_text_search → eql_v3_text_search + const prefix = 'eql_v3_' + if (!bare.startsWith(prefix)) return null + const suffix = bare.slice(prefix.length) + // No index suffix (bare storage-only domain like `boolean`, `text`) → no query + // domain exists. These are gated out before any operand is encrypted. The + // suffixes match the column factories in `@/eql/v3/columns` exactly: ope + // ordering is the `_ord` domain (not `_ord_ope`) and text search is `_search` + // (there is no `_search_ore` column), so those two never occur here. + if (!/_(eq|ord|ord_ore|match|search)$/.test(suffix)) { + return null + } + return `eql_v3.query_${suffix}` +} + +export type EncryptionOperatorCallOpts = { + lockContext?: LockContext + audit?: AuditConfig +} + +/** + * An SDK encryption operation after its lock context has been applied: still + * auditable and awaitable, but not re-lockable. `withLockContext` returns this, + * not the full {@link ChainableOperation}, mirroring the real + * `EncryptOperationWithLockContext`, which drops `withLockContext` (you cannot + * lock-context twice). Modelling that is what lets the real client type satisfy + * the structural surface with no cast. + */ +type AuditableOperation = { + audit(config: AuditConfig): AuditableOperation + then: PromiseLike>['then'] +} + +/** + * The subset of an SDK encryption operation this factory drives: the fluent + * `withLockContext`/`audit` chain, and a `then` that resolves the operation's + * `Result`. Generic over the resolved payload `T` so the single `encryptQuery` + * carries an `EncryptedQueryResult` term and the batch form an + * `EncryptedQueryResult[]`, rather than the `unknown` this erased to before. + * + * Structural, not the concrete `EncryptQueryOperation` class, because the client + * is passed in and the factory must accept any implementation with this surface. + */ +type ChainableOperation = { + withLockContext(lockContext: LockContext): AuditableOperation + audit(config: AuditConfig): AuditableOperation + then: PromiseLike>['then'] +} + +/** + * Build v3-aware query operators (`eq`, `gte`, `matches`, `contains`, `asc`, …) bound to an + * encryption `client`. Each comparison/containment operator AUTO-ENCRYPTS its + * plaintext operand into an EQL v3 query term before handing it to Drizzle, so + * callers pass plaintext and the emitted SQL compares encrypted values. Every + * operator also gates on the target column's capabilities and throws + * {@link EncryptionOperatorError} when the column can't answer the operator + * (e.g. ordering a non-`ore` column). + * + * @param client - anything that can `encryptQuery` — the nominal + * `EncryptionClient` or the `TypedEncryptionClient` from `EncryptionV3` (no + * cast needed). + * @param defaults - lock context / audit applied to every operand encryption + * unless a per-call override is supplied. + * + * @example + * ```typescript + * const ops = createEncryptionOperatorsV3(await EncryptionV3({ schemas: [users] })) + * await db.select().from(users).where(await ops.eq(users.email, 'a@b.com')) + * ``` + */ +export function createEncryptionOperatorsV3( + client: OperandEncryptionClient, + defaults: EncryptionOperatorCallOpts = {}, +) { + const tableCache = new WeakMap() + // Per-column context memo. `resolveContext` is value-independent, so caching + // by column identity makes `inArray`/`notInArray` build the context (and its + // deep-cloned match block) once for the whole list instead of once per value. + const contextCache = new WeakMap() + + function drizzleTableOf(column: SQLWrapper): PgTable | undefined { + return is(column, Column) + ? (column.table as PgTable | undefined) + : undefined + } + + function resolveContext(column: SQLWrapper, operator: string): ColumnContext { + const cached = contextCache.get(column) + if (cached) return cached + + const columnName = is(column, Column) ? column.name : 'unknown' + const builder = getEqlV3Column(columnName, column) + if (!builder) { + throw new EncryptionOperatorError( + `Operator "${operator}" requires an encrypted v3 column, but "${columnName}" is not one.`, + { columnName, operator }, + ) + } + + const drizzleTable = drizzleTableOf(column) + const tableName = getDrizzleTableName(drizzleTable) ?? 'unknown' + + let table = drizzleTable ? tableCache.get(drizzleTable) : undefined + if (!table && drizzleTable) { + table = extractEncryptionSchemaV3(drizzleTable) + tableCache.set(drizzleTable, table) + } + if (!table) { + throw new EncryptionOperatorError( + `Unable to resolve the encrypted table for column "${columnName}".`, + { columnName, operator }, + ) + } + + const context: ColumnContext = { + builder, + table, + indexes: builder.build().indexes, + columnName, + tableName, + queryCast: queryCastForDomain(builder.getEqlType()), + } + contextCache.set(column, context) + return context + } + + /** + * Gate an operator on the column's indexes. `indexes` is a disjunction — any + * one of them grants the capability — so equality (`unique` OR `ore`) and the + * single-index gates share one rule and one diagnostic shape. + */ + function requireIndex( + ctx: ColumnContext, + indexes: readonly ('unique' | 'ore' | 'ope' | 'match' | 'ste_vec')[], + operator: string, + capability: string, + ): void { + if (!indexes.some((index) => ctx.indexes[index])) { + throw new EncryptionOperatorError( + `Operator "${operator}" requires ${capability} on column "${ctx.columnName}" (domain ${ctx.builder.getEqlType()} does not support it).`, + { columnName: ctx.columnName, tableName: ctx.tableName, operator }, + ) + } + } + + // Ordering flavour is pinned by the column's domain (eql-3.0.0): `_ord` + // domains carry `ope` (`op` CLLW-OPE term), `_ord_ore` domains carry `ore` + // (`ob` block-ORE term). Either satisfies the order/range operators, and an + // order-capable column answers equality via its ordering term too. + const EQUALITY_INDEXES = ['unique', 'ore', 'ope'] as const + const ORDERING_INDEXES = ['ore', 'ope'] as const + // Two DISTINCT operators, split by semantics (#617): + // - `matches` is bloom free-text (`match`, a `text_search`/`text_match` + // column): a one-sided, order- and multiplicity-insensitive token match that + // may false-positive. It emits `eql_v3.contains(col, operand)` (the SQL + // function keeps its bundle name) but is NOT containment. + // - `contains` is encrypted-JSONB containment (an `eql_v3_json` column, + // `ste_vec` index): exact jsonb `@>`, no false positives — genuine + // containment, so it keeps the `contains` name. + const MATCH_INDEXES = ['match'] as const + const JSON_CONTAINMENT_INDEXES = ['ste_vec'] as const + + function applyOperationOptions( + op: ChainableOperation, + opts?: EncryptionOperatorCallOpts, + ): AuditableOperation { + const lockContext = opts?.lockContext ?? defaults.lockContext + const audit = opts?.audit ?? defaults.audit + const withLock = lockContext ? op.withLockContext(lockContext) : op + if (audit) withLock.audit(audit) + return withLock + } + + function requireNonNullOperand( + ctx: ColumnContext, + value: unknown, + operator: string, + ): void { + if (value == null) { + throw new EncryptionOperatorError( + `Operator "${operator}" cannot encrypt a null operand for column "${ctx.columnName}". Use isNull() or isNotNull() for NULL checks.`, + { + columnName: ctx.columnName, + tableName: ctx.tableName, + operator, + }, + ) + } + } + + /** + * Reject a free-text needle the column's match index cannot answer. A needle + * shorter than the tokenizer's `token_length` yields an empty bloom filter, + * and `stored_bf @> '{}'` holds for every row — so without this the query + * silently returns the whole table. + */ + function requireAnswerableNeedle( + ctx: ColumnContext, + value: unknown, + operator: string, + ): void { + const match = ctx.indexes.match + if (!match) return + const reason = matchNeedleError(value, match) + if (reason) { + throw new EncryptionOperatorError( + `Operator "${operator}" cannot search column "${ctx.columnName}": ${reason}`, + { columnName: ctx.columnName, tableName: ctx.tableName, operator }, + ) + } + } + + function operandFailure( + ctx: ColumnContext, + operator: string, + reason: string, + ): EncryptionOperatorError { + return new EncryptionOperatorError( + `Failed to encrypt query operand for "${ctx.columnName}": ${reason}`, + { columnName: ctx.columnName, tableName: ctx.tableName, operator }, + ) + } + + /** + * Render a query term as a cast operand: `''::eql_v3.query_`. + * The cast is what reaches the bundle's `(domain, query_)` overloads — + * a bare `::jsonb` would hit the storage-domain overload, whose CHECK demands + * the ciphertext `c` a query term deliberately omits. `queryCast` is derived + * from the column's own domain (see `queryCastForDomain`), so `sql.raw` is safe. + */ + function castOperand( + ctx: ColumnContext, + operator: string, + term: EncryptedQueryResult, + ): SQL { + if (ctx.queryCast === null) { + throw operandFailure( + ctx, + operator, + `column domain "${ctx.builder.getEqlType()}" has no query operand type.`, + ) + } + return sql`${JSON.stringify(term)}::${sql.raw(ctx.queryCast)}` + } + + async function encryptOperand( + ctx: ColumnContext, + value: unknown, + operator: string, + queryType: QueryTypeName, + opts?: EncryptionOperatorCallOpts, + ): Promise { + requireNonNullOperand(ctx, value, operator) + + const result = await applyOperationOptions( + client.encryptQuery( + value as never, + { + table: ctx.table, + column: ctx.builder, + queryType, + } as never, + ), + opts, + ) + if (result.failure) { + throw operandFailure(ctx, operator, result.failure.message) + } + return castOperand(ctx, operator, result.data) + } + + /** + * Encrypt a whole operand list in ONE `encryptQuery` batch crossing (rather + * than one per value). The batch is position-stable, so the returned terms + * align index-for-index with `values`; a response of a different length means + * the contract was violated and is rejected rather than silently truncating + * the predicate (which would widen an `inArray` or narrow a `notInArray`). + * Null operands are rejected up front, so no term is filtered out of the batch. + */ + async function encryptOperands( + ctx: ColumnContext, + values: unknown[], + operator: string, + queryType: QueryTypeName, + opts?: EncryptionOperatorCallOpts, + ): Promise { + for (const value of values) requireNonNullOperand(ctx, value, operator) + + const terms = values.map((value) => ({ + value, + column: ctx.builder, + table: ctx.table, + queryType, + })) + const result = await applyOperationOptions( + client.encryptQuery(terms as never), + opts, + ) + if (result.failure) { + throw operandFailure(ctx, operator, result.failure.message) + } + + const encrypted = result.data as EncryptedQueryResult[] + if (encrypted.length !== values.length) { + throw operandFailure( + ctx, + operator, + `batch query encryption returned ${encrypted.length} terms for ${values.length} values.`, + ) + } + return encrypted.map((term) => castOperand(ctx, operator, term)) + } + + const colSql = (column: SQLWrapper): SQL => sql`${column}` + + async function equality( + op: EqualityOp, + left: SQLWrapper, + right: unknown, + opts?: EncryptionOperatorCallOpts, + ): Promise { + const ctx = resolveContext(left, op) + requireIndex(ctx, EQUALITY_INDEXES, op, 'equality') + const enc = await encryptOperand(ctx, right, op, 'equality', opts) + return v3Dialect.equality(op, colSql(left), enc) + } + + async function comparison( + op: ComparisonOp, + left: SQLWrapper, + right: unknown, + opts?: EncryptionOperatorCallOpts, + ): Promise { + const ctx = resolveContext(left, op) + requireIndex(ctx, ORDERING_INDEXES, op, 'order/range') + const enc = await encryptOperand(ctx, right, op, 'orderAndRange', opts) + return v3Dialect.comparison(op, colSql(left), enc) + } + + async function range( + left: SQLWrapper, + min: unknown, + max: unknown, + negate: boolean, + operator: string, + opts?: EncryptionOperatorCallOpts, + ): Promise { + const ctx = resolveContext(left, operator) + requireIndex(ctx, ORDERING_INDEXES, operator, 'order/range') + // Independent operands — encrypt concurrently rather than paying two + // sequential round-trips to the crypto backend. + const [encMin, encMax] = await Promise.all([ + encryptOperand(ctx, min, operator, 'orderAndRange', opts), + encryptOperand(ctx, max, operator, 'orderAndRange', opts), + ]) + // `v3Dialect.range` is already parenthesised, so `NOT` binds to the whole + // conjunction without a wrapper here. + const condition = v3Dialect.range(colSql(left), encMin, encMax) + return negate ? sql`NOT ${condition}` : condition + } + + /** + * Fuzzy free-text token match on a `text_search`/`text_match` column. NOT + * containment: it tests whether the needle's downcased 3-gram set is a subset + * of the haystack's, via a bloom filter — order- and multiplicity-insensitive + * and one-sided (a `true` may be a false positive, a `false` never is). Emits + * `eql_v3.contains(col, operand)` (the SQL function's bundle name). + */ + async function matches( + left: SQLWrapper, + right: unknown, + operator: string, + opts?: EncryptionOperatorCallOpts, + ): Promise { + const ctx = resolveContext(left, operator) + requireIndex(ctx, MATCH_INDEXES, operator, 'free-text search') + // The answerable-needle rule applies (a sub-`token_length` needle blooms to + // nothing and would match every row); the `query_` cast reaches the + // match overload. + requireAnswerableNeedle(ctx, right, operator) + const enc = await encryptOperand( + ctx, + right, + operator, + 'freeTextSearch', + opts, + ) + return v3Dialect.contains(colSql(left), enc) + } + + /** + * Exact encrypted-JSONB containment on an `eql_v3_json` (`ste_vec`) column: + * genuine jsonb `@>`, no false positives — hence it keeps the `contains` name. + * `eql_v3_json` has no `eql_v3.contains` overload; containment is the `@>` + * operator, whose `(eql_v3_json, eql_v3.query_jsonb)` form takes a NARROWED + * query term (searchableJson → no ciphertext), cast to `eql_v3.query_jsonb`. + */ + async function containsJsonOp( + left: SQLWrapper, + right: unknown, + operator: string, + opts?: EncryptionOperatorCallOpts, + ): Promise { + const ctx = resolveContext(left, operator) + requireIndex(ctx, JSON_CONTAINMENT_INDEXES, operator, 'JSON containment') + const needle = await encryptJsonContainmentTerm(ctx, right, operator, opts) + return v3Dialect.containsJson(colSql(left), needle) + } + + /** + * Build a `query_jsonb` containment needle for a `json` column — the JSON query + * term carries no ciphertext and satisfies the `eql_v3.query_jsonb` CHECK the + * `@>` overload needs. Cast here (not by `queryCastForDomain`): a json column's + * domain is `eql_v3_json` but its query operand type is the irregular + * `eql_v3.query_jsonb`. + */ + async function encryptJsonContainmentTerm( + ctx: ColumnContext, + value: unknown, + operator: string, + opts?: EncryptionOperatorCallOpts, + ): Promise { + requireNonNullOperand(ctx, value, operator) + // Reject the empty-object needle. `doc @> '{}'` holds for EVERY document + // (jsonb `{} ⊆ anything`), so `contains(col, {})` would silently return the + // whole table — the same whole-table footgun the bloom path guards against + // with `requireAnswerableNeedle`. An accidental empty filter is a bug, not a + // match-all request; callers wanting every row should omit the predicate. + if ( + value !== null && + typeof value === 'object' && + !Array.isArray(value) && + Object.keys(value).length === 0 + ) { + throw new EncryptionOperatorError( + `Operator "${operator}" cannot take an empty object needle on column "${ctx.columnName}": it matches every row. Pass a non-empty sub-object, or omit the predicate to select all rows.`, + { columnName: ctx.columnName, tableName: ctx.tableName, operator }, + ) + } + const result = await applyOperationOptions( + client.encryptQuery( + value as never, + { + table: ctx.table, + column: ctx.builder, + queryType: 'searchableJson', + } as never, + ), + opts, + ) + if (result.failure) { + throw operandFailure(ctx, operator, result.failure.message) + } + return sql`${JSON.stringify(result.data)}::eql_v3.query_jsonb` + } + + async function inArrayOp( + left: SQLWrapper, + values: unknown[], + negate: boolean, + operator: string, + opts?: EncryptionOperatorCallOpts, + ): Promise { + const ctx = resolveContext(left, operator) + if (values.length === 0) { + throw new EncryptionOperatorError( + `Operator "${operator}" requires a non-empty list of values for column "${ctx.columnName}".`, + { columnName: ctx.columnName, tableName: ctx.tableName, operator }, + ) + } + // Gate and resolve the context once for the whole list, then encrypt it in + // a single `encryptQuery` batch crossing. + requireIndex(ctx, EQUALITY_INDEXES, operator, 'equality') + const op: EqualityOp = negate ? 'ne' : 'eq' + const encrypted = await encryptOperands( + ctx, + values, + operator, + 'equality', + opts, + ) + const conditions = encrypted.map((enc) => + v3Dialect.equality(op, colSql(left), enc), + ) + // The empty-list guard above leaves `conditions` non-empty, so `and`/`or` + // never return undefined here. + return (negate ? and(...conditions) : or(...conditions)) as SQL + } + + function orderTerm(column: SQLWrapper, operator: string): SQL { + const ctx = resolveContext(column, operator) + requireIndex(ctx, ORDERING_INDEXES, operator, 'order/range') + return v3Dialect.orderBy(colSql(column), ctx.indexes.ore ? 'ore' : 'ope') + } + + async function combine( + joiner: typeof and, + empty: SQL, + conditions: (SQL | SQLWrapper | Promise | undefined)[], + ): Promise { + const present = conditions.filter( + (c): c is SQL | SQLWrapper | Promise => c !== undefined, + ) + const resolved = await Promise.all(present) + return joiner(...resolved) ?? empty + } + + return { + /** Equality: `column = value`. Encrypts `r` and emits `eql_v3.eq`. + * Requires a `unique` or `ore` index on the column. */ + eq: (l: SQLWrapper, r: unknown, opts?: EncryptionOperatorCallOpts) => + equality('eq', l, r, opts), + /** Inequality: `column <> value`. Encrypts `r` and emits `eql_v3.neq`. + * Requires a `unique` or `ore` index on the column. */ + ne: (l: SQLWrapper, r: unknown, opts?: EncryptionOperatorCallOpts) => + equality('ne', l, r, opts), + /** Greater-than: `column > value`. Encrypts `r` and emits `eql_v3.gt`. + * Requires an `ore` (order/range) index. */ + gt: (l: SQLWrapper, r: unknown, opts?: EncryptionOperatorCallOpts) => + comparison('gt', l, r, opts), + /** Greater-than-or-equal: `column >= value`. Encrypts `r` and emits + * `eql_v3.gte`. Requires an `ore` (order/range) index. */ + gte: (l: SQLWrapper, r: unknown, opts?: EncryptionOperatorCallOpts) => + comparison('gte', l, r, opts), + /** Less-than: `column < value`. Encrypts `r` and emits `eql_v3.lt`. + * Requires an `ore` (order/range) index. */ + lt: (l: SQLWrapper, r: unknown, opts?: EncryptionOperatorCallOpts) => + comparison('lt', l, r, opts), + /** Less-than-or-equal: `column <= value`. Encrypts `r` and emits + * `eql_v3.lte`. Requires an `ore` (order/range) index. */ + lte: (l: SQLWrapper, r: unknown, opts?: EncryptionOperatorCallOpts) => + comparison('lte', l, r, opts), + /** Inclusive range `min <= column <= max`. Encrypts both bounds + * concurrently. Requires an `ore` (order/range) index. */ + between: ( + l: SQLWrapper, + min: unknown, + max: unknown, + opts?: EncryptionOperatorCallOpts, + ) => range(l, min, max, false, 'between', opts), + /** Negated inclusive range `NOT (min <= column <= max)`. Encrypts both + * bounds concurrently. Requires an `ore` (order/range) index. */ + notBetween: ( + l: SQLWrapper, + min: unknown, + max: unknown, + opts?: EncryptionOperatorCallOpts, + ) => range(l, min, max, true, 'notBetween', opts), + /** Fuzzy free-text token match — the needle's 3-gram set is (bloom-)tested + * as a subset of the column's. NOT containment: order/multiplicity- + * insensitive and one-sided (a `true` may be a false positive). Encrypts + * `r`. Requires a `match` (free-text search) index. */ + matches: (l: SQLWrapper, r: unknown, opts?: EncryptionOperatorCallOpts) => + matches(l, r, 'matches', opts), + /** Exact encrypted-JSONB containment (`@>`): matches rows whose document + * contains the given sub-object. No false positives. Encrypts `r`. Requires + * a `ste_vec` index (a `types.Json` column). */ + contains: (l: SQLWrapper, r: unknown, opts?: EncryptionOperatorCallOpts) => + containsJsonOp(l, r, 'contains', opts), + /** Membership: ORs one encrypted `eq` term per value. The whole list is + * encrypted in one `encryptQuery` batch crossing. Rejects an empty list; + * requires a `unique` or `ore` index. */ + inArray: ( + l: SQLWrapper, + values: unknown[], + opts?: EncryptionOperatorCallOpts, + ) => inArrayOp(l, values, false, 'inArray', opts), + /** Non-membership: ANDs one encrypted `ne` term per value. The whole list + * is encrypted in one `encryptQuery` batch crossing. Rejects an empty list; + * requires a `unique` or `ore` index. */ + notInArray: ( + l: SQLWrapper, + values: unknown[], + opts?: EncryptionOperatorCallOpts, + ) => inArrayOp(l, values, true, 'notInArray', opts), + /** Ascending order by the encrypted order term (`eql_v3.ord_term` / + * `eql_v3.ord_term_ore`, by the column's ordering flavour). + * Synchronous (no operand to encrypt). Requires an ordering index. */ + asc: (c: SQLWrapper) => asc(orderTerm(c, 'asc')), + /** Descending order by the encrypted order term (`eql_v3.ord_term` / + * `eql_v3.ord_term_ore`, by the column's ordering flavour). + * Synchronous (no operand to encrypt). Requires an ordering index. */ + desc: (c: SQLWrapper) => desc(orderTerm(c, 'desc')), + /** Conjunction of the given conditions, awaiting any async operands and + * dropping `undefined`. Empty input resolves to `true`. */ + and: (...conds: (SQL | SQLWrapper | Promise | undefined)[]) => + combine(and, sql`true`, conds), + /** Disjunction of the given conditions, awaiting any async operands and + * dropping `undefined`. Empty input resolves to `false`. */ + or: (...conds: (SQL | SQLWrapper | Promise | undefined)[]) => + combine(or, sql`false`, conds), + /** Drizzle's `isNull`, re-exported unchanged — `column IS NULL` needs no + * encryption and works on any (nullable) encrypted column. */ + isNull, + /** Drizzle's `isNotNull`, re-exported unchanged — `column IS NOT NULL` + * needs no encryption. */ + isNotNull, + /** Drizzle's `not`, re-exported unchanged — negates an already-built + * (encrypted) predicate. Safe over any operator here, including `between`, + * whose fragment is self-parenthesising. */ + not, + /** Drizzle's `exists`, re-exported unchanged — for correlated subqueries. */ + exists, + /** Drizzle's `notExists`, re-exported unchanged — for correlated + * subqueries. */ + notExists, + } +} diff --git a/packages/stack-drizzle/src/v3/schema-extraction.ts b/packages/stack-drizzle/src/v3/schema-extraction.ts new file mode 100644 index 000000000..68f8796bb --- /dev/null +++ b/packages/stack-drizzle/src/v3/schema-extraction.ts @@ -0,0 +1,50 @@ +import { + type AnyEncryptedV3Column, + type AnyV3Table, + encryptedTable, +} from '@cipherstash/stack/eql/v3' +import type { PgTable } from 'drizzle-orm/pg-core' +import { getEqlV3Column } from './column.js' + +/** Drizzle stashes the SQL table name on this well-known symbol key. */ +const DRIZZLE_NAME = Symbol.for('drizzle:Name') + +/** + * Read the SQL table name Drizzle stashes on a `pgTable`. Returns `undefined` + * for a non-object or a table not built with `pgTable()`. Shared by + * {@link extractEncryptionSchemaV3} and the operator factory so the + * symbol-key introspection lives in exactly one place. + */ +export function getDrizzleTableName(table: unknown): string | undefined { + if (!table || typeof table !== 'object') return undefined + const name = (table as Record)[DRIZZLE_NAME] + return typeof name === 'string' ? name : undefined +} + +export function extractEncryptionSchemaV3(table: PgTable): AnyV3Table { + const tableName = getDrizzleTableName(table) + if (!tableName) { + throw new Error( + 'Unable to read table name from Drizzle table. Use a table created with pgTable().', + ) + } + + const columns: Record = {} + for (const [property, column] of Object.entries(table)) { + if (typeof column !== 'object' || column === null) continue + const columnName = + 'name' in column && typeof column.name === 'string' + ? column.name + : property + const builder = getEqlV3Column(columnName, column) + if (builder) columns[property] = builder + } + + if (Object.keys(columns).length === 0) { + throw new Error( + `No encrypted v3 columns found in table "${tableName}". Declare columns with the v3 drizzle \`types\` namespace.`, + ) + } + + return encryptedTable(tableName, columns) +} diff --git a/packages/stack-drizzle/src/v3/sql-dialect.ts b/packages/stack-drizzle/src/v3/sql-dialect.ts new file mode 100644 index 000000000..38a3a5f1a --- /dev/null +++ b/packages/stack-drizzle/src/v3/sql-dialect.ts @@ -0,0 +1,75 @@ +import { type SQL, sql } from 'drizzle-orm' + +export type EqualityOp = 'eq' | 'ne' +export type ComparisonOp = 'gt' | 'gte' | 'lt' | 'lte' + +/** + * The schema the EQL v3 comparison functions live in. The concrete `public.*` + * domains are derived from the column factories (see `column.ts`); the + * functions that operate on them are namespaced separately, so they get their + * own single source of truth. + */ +export const EQL_V3_FN_SCHEMA = 'eql_v3' + +const fn = (name: string): SQL => sql.raw(`${EQL_V3_FN_SCHEMA}.${name}`) + +/** + * Emit the EQL v3 comparison/containment SQL. Every operand `enc` arrives ALREADY + * cast to its `eql_v3.query_` type by the operator layer (see + * `operators.ts` — the term comes from `encryptQuery`, so it is ciphertext-free + * and matches the `query_` CHECK). The dialect therefore adds no cast of + * its own; it only places the pre-cast operand into the right function/operator. + * This reaches the `(domain, query_)` overloads the bundle defines for + * narrowed query terms, rather than the `(domain, jsonb)` overload that coerces + * to the storage domain and demands the ciphertext `c`. + */ +export const v3Dialect = { + equality(op: EqualityOp, left: SQL, enc: SQL): SQL { + return sql`${fn(op === 'eq' ? 'eq' : 'neq')}(${left}, ${enc})` + }, + + comparison(op: ComparisonOp, left: SQL, enc: SQL): SQL { + return sql`${fn(op)}(${left}, ${enc})` + }, + + /** + * Inclusive range, emitted as a SELF-CONTAINED parenthesised conjunction. + * + * The parentheses are load-bearing: this is the only helper returning more + * than one function call, and Drizzle's `not` renders `not ${condition}` + * without adding any of its own. Postgres binds NOT tighter than AND, so a + * bare fragment would make `not(between(col, x, y))` parse as + * `(NOT gte(col, x)) AND lte(col, y)` — rows below the lower bound rather + * than the complement of the range. Parenthesising here makes every + * composition safe instead of asking each caller to remember. + */ + range(left: SQL, min: SQL, max: SQL): SQL { + return sql`(${fn('gte')}(${left}, ${min}) AND ${fn('lte')}(${left}, ${max}))` + }, + + contains(left: SQL, enc: SQL): SQL { + return sql`${fn('contains')}(${left}, ${enc})` + }, + + /** + * Encrypted-JSONB containment (`eql_v3_json @> sub-document`). Unlike text, + * json has NO `eql_v3.contains` overload — containment is the `@>` operator, + * whose `(eql_v3_json, eql_v3.query_jsonb)` form takes the `query_jsonb` needle + * the operator layer produced. The four `eql_v3_json @> ?` RHS overloads mean a + * bare operand would be ambiguous ("operator is not unique", 42725), so the + * needle is pre-cast to `eql_v3.query_jsonb` upstream (see + * `encryptJsonContainmentTerm`). + */ + containsJson(left: SQL, enc: SQL): SQL { + return sql`${left} OPERATOR(public.@>) ${enc}` + }, + + orderBy(left: SQL, flavour: 'ope' | 'ore'): SQL { + // eql-3.0.0 splits the ordering extractor by term flavour: `ord_term` + // takes the OPE-backed `_ord` domains (returns eql_v3_internal.ope_cllw), + // `ord_term_ore` the block-ORE `_ord_ore` domains (ore_block_256). + return flavour === 'ore' + ? sql`${fn('ord_term_ore')}(${left})` + : sql`${fn('ord_term')}(${left})` + }, +} diff --git a/packages/stack-drizzle/src/v3/types.ts b/packages/stack-drizzle/src/v3/types.ts new file mode 100644 index 000000000..443382bc9 --- /dev/null +++ b/packages/stack-drizzle/src/v3/types.ts @@ -0,0 +1,19 @@ +import { types as v3Types } from '@cipherstash/stack/eql/v3' +import { makeEqlV3Column } from './column.js' + +type V3Types = typeof v3Types + +/** + * Drizzle-native mirror of `@/eql/v3`'s `types` namespace. Each PascalCase + * factory returns a Drizzle column wrapping the matching concrete v3 builder. + */ +export const types = Object.fromEntries( + Object.entries(v3Types).map(([name, factory]) => [ + name, + (columnName: string) => makeEqlV3Column(factory(columnName)), + ]), +) as { + [K in keyof V3Types]: ( + name: string, + ) => ReturnType>> +} diff --git a/packages/stack-drizzle/tsconfig.json b/packages/stack-drizzle/tsconfig.json new file mode 100644 index 000000000..87838c567 --- /dev/null +++ b/packages/stack-drizzle/tsconfig.json @@ -0,0 +1,40 @@ +{ + "compilerOptions": { + "lib": ["ES2022", "DOM"], + "target": "ES2022", + "module": "ESNext", + "moduleDetection": "force", + "allowJs": true, + "esModuleInterop": true, + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "verbatimModuleSyntax": true, + "noEmit": true, + "customConditions": ["node"], + "strict": true, + "skipLibCheck": true, + "noFallthroughCasesInSwitch": true, + "noUnusedLocals": false, + "noUnusedParameters": false, + "paths": { + "@cipherstash/stack": ["../stack/src/index.ts"], + "@cipherstash/stack/adapter-kit": ["../stack/src/adapter-kit.ts"], + "@cipherstash/stack/encryption": ["../stack/src/encryption/index.ts"], + "@cipherstash/stack/schema": ["../stack/src/schema/index.ts"], + "@cipherstash/stack/identity": ["../stack/src/identity/index.ts"], + "@cipherstash/stack/errors": ["../stack/src/errors/index.ts"], + "@cipherstash/stack/types": ["../stack/src/types-public.ts"], + "@cipherstash/stack/eql/v3": ["../stack/src/eql/v3/index.ts"], + "@cipherstash/stack/v3": ["../stack/src/encryption/v3.ts"], + "@cipherstash/test-kit": ["../test-kit/src/index.ts"], + "@cipherstash/test-kit/suite": ["../test-kit/src/run-family-suite.ts"], + "@cipherstash/test-kit/integration-clerk": [ + "../test-kit/src/integration/clerk.ts" + ], + "@cipherstash/test-kit/catalog": ["../test-kit/src/catalog.ts"], + "@/*": ["../stack/src/*"] + } + }, + "include": ["src/**/*.ts", "__tests__/**/*.ts", "integration/**/*.ts"], + "exclude": ["dist", "node_modules"] +} diff --git a/packages/stack-drizzle/tsconfig.typecheck.json b/packages/stack-drizzle/tsconfig.typecheck.json new file mode 100644 index 000000000..9d06679f0 --- /dev/null +++ b/packages/stack-drizzle/tsconfig.typecheck.json @@ -0,0 +1,4 @@ +{ + "extends": "./tsconfig.json", + "include": ["__tests__/**/*.test-d.ts"] +} diff --git a/packages/stack-drizzle/tsup.config.ts b/packages/stack-drizzle/tsup.config.ts new file mode 100644 index 000000000..19ce5967e --- /dev/null +++ b/packages/stack-drizzle/tsup.config.ts @@ -0,0 +1,13 @@ +import { defineConfig } from 'tsup' + +export default defineConfig({ + entry: ['src/index.ts', 'src/v3/index.ts'], + outDir: 'dist', + format: ['cjs', 'esm'], + sourcemap: true, + dts: true, + clean: false, + target: 'es2022', + tsconfig: './tsconfig.json', + external: ['@cipherstash/stack', '@cipherstash/protect-ffi', 'drizzle-orm'], +}) diff --git a/packages/stack-drizzle/vitest.config.ts b/packages/stack-drizzle/vitest.config.ts new file mode 100644 index 000000000..9fed3fefd --- /dev/null +++ b/packages/stack-drizzle/vitest.config.ts @@ -0,0 +1,18 @@ +import { configDefaults, defineConfig } from 'vitest/config' +import { sharedAlias, stackSourceAlias } from '../../vitest.shared' + +export default defineConfig({ + resolve: { + // See stack-supabase/vitest.config.ts for what these two alias blocks do. + alias: { ...sharedAlias, ...stackSourceAlias }, + }, + test: { + exclude: [...configDefaults.exclude, 'integration/**'], + testTimeout: 30000, + hookTimeout: 30000, + typecheck: { + tsconfig: './tsconfig.typecheck.json', + include: ['__tests__/**/*.test-d.ts'], + }, + }, +}) diff --git a/packages/stack-supabase/README.md b/packages/stack-supabase/README.md new file mode 100644 index 000000000..4e5a3e063 --- /dev/null +++ b/packages/stack-supabase/README.md @@ -0,0 +1,33 @@ +# @cipherstash/stack-supabase + +Supabase integration for [CipherStash Stack](https://www.npmjs.com/package/@cipherstash/stack) — +transparent, searchable field-level encryption on top of a Supabase (PostgREST) client. + +Depends on `@cipherstash/stack`; install both: + +```bash +npm install @cipherstash/stack @cipherstash/stack-supabase @supabase/supabase-js +``` + +## EQL v3 (recommended) + +`encryptedSupabaseV3` introspects the database at connect time (native +`public.eql_v3_*` column domains) — no schema argument, `select('*')` support, +`contains()` free-text search, and encrypted `order()` on OPE columns. + +```ts +import { encryptedSupabaseV3 } from '@cipherstash/stack-supabase' + +const es = await encryptedSupabaseV3(supabaseUrl, supabaseKey) +await es.from('users').select('id, email').eq('email', 'a@b.com') +``` + +Introspection needs a direct Postgres connection (`DATABASE_URL`), so `pg` is an +optional peer and the factory cannot run in a Worker or the browser. + +## EQL v2 (legacy) + +`encryptedSupabase` wraps a supabase-js client with a v2 schema; still shipped for +existing v2 deployments. + +See the `stash-supabase` agent skill and https://cipherstash.com/docs for the full guide. diff --git a/packages/stack-supabase/__tests__/helpers/postgrest-wire.ts b/packages/stack-supabase/__tests__/helpers/postgrest-wire.ts new file mode 100644 index 000000000..b535606eb --- /dev/null +++ b/packages/stack-supabase/__tests__/helpers/postgrest-wire.ts @@ -0,0 +1,68 @@ +/** + * A test double that can see the WIRE FORMAT. + * + * `createMockSupabase` records the arguments handed to each builder method and + * stops there. That pins per-element *encryption* but is structurally blind to + * *encoding*: postgrest-js still has to serialize those arguments into a query + * string, and that is where an unescaped `"` inside an encrypted envelope turns + * `in.(…)` into a request PostgREST rejects. A mock that never builds a URL can + * never catch it. + * + * So this harness runs the REAL `PostgrestClient` with a `fetch` that captures + * the request URL and answers with canned rows. No database, no `DATABASE_URL` + * gate — but the operand is byte-for-byte what a live PostgREST would receive. + * + * Use it for anything whose correctness lives in the emitted query string + * (`in`, `not.in`, `or`); keep using `createMockSupabase` for everything else. + */ + +import { PostgrestClient } from '@supabase/postgrest-js' +import type { SupabaseQueryBuilder } from '../../src/types' + +export type WirePostgrest = { + /** Structurally a supabase client: `.from(table)` → a query builder. */ + client: { from(table: string): SupabaseQueryBuilder } + /** Every request URL issued, in order. */ + urls: string[] + /** The decoded operand for `column` on the last request, e.g. `in.("…","…")`. */ + operandFor(column: string): string +} + +export function createWirePostgrest(resultData: unknown = []): WirePostgrest { + const urls: string[] = [] + + const fetchImpl = (input: unknown): Promise => { + urls.push( + typeof input === 'string' + ? input + : String((input as { url: string }).url ?? input), + ) + return Promise.resolve( + new Response(JSON.stringify(resultData), { + status: 200, + headers: { 'Content-Type': 'application/json' }, + }), + ) + } + + const client = new PostgrestClient('http://wire.test', { + fetch: fetchImpl as unknown as typeof fetch, + }) + + return { + client: client as unknown as WirePostgrest['client'], + urls, + operandFor(column: string): string { + const last = urls.at(-1) + if (last === undefined) throw new Error('no request was issued') + // `searchParams.get` percent-decodes; PostgREST sees exactly this. + const value = new URL(last).searchParams.get(column) + if (value === null) { + throw new Error( + `no filter emitted for column "${column}" in ${new URL(last).search}`, + ) + } + return value + }, + } +} diff --git a/packages/stack-supabase/__tests__/helpers/supabase-mock.ts b/packages/stack-supabase/__tests__/helpers/supabase-mock.ts new file mode 100644 index 000000000..a72efd619 --- /dev/null +++ b/packages/stack-supabase/__tests__/helpers/supabase-mock.ts @@ -0,0 +1,209 @@ +/** + * Test doubles for the Supabase query-builder suites. + * + * The builders only touch a narrow slice of the encryption client and the + * supabase client, so both are simulated: the encryption mock produces + * deterministic fake envelopes (carrying the plaintext in `pt` so the fake + * decrypt can undo them), and the supabase mock records every builder call. + * This pins the WIRE ENCODING each dialect produces — the part of the adapter + * that CI can verify without a live Supabase project. + * + * Extracted verbatim from `supabase-v3-builder.test.ts` so the 39-domain wire + * sweep (`supabase-v3-matrix.test.ts`) drives the adapter through the exact + * same doubles, and a change to either mock moves both suites together. + */ + +import type { EncryptionClient } from '@cipherstash/stack/encryption' + +export type FakeEnvelope = { + v: 2 + i: { t: string; c: string } + c: string + hm: string + pt: unknown +} + +export function fakeEnvelope(value: unknown, column: string): FakeEnvelope { + // `pt` is carried through `JSON.stringify` by the v3 filter path + // (`encryptCollectedTerms`), so it must be JSON-serializable. A real + // envelope only ever holds strings; normalize the two plaintext types that + // are not — `Date` and `bigint` — rather than letting the mock throw where + // the product would not. The `bigint` domains' samples are the only reason + // this matters. + const pt = + value instanceof Date + ? value.toISOString() + : typeof value === 'bigint' + ? value.toString() + : value + return { + v: 2, + i: { t: 'tbl', c: column }, + c: `ct:${String(pt)}`, + hm: `hm:${String(pt)}`, + pt, + } +} + +export function isFakeEnvelope(value: unknown): value is FakeEnvelope { + return ( + typeof value === 'object' && + value !== null && + 'pt' in value && + 'c' in value && + 'hm' in value + ) +} + +/** A chainable operation resolving to `{ data }`, like the real ones. */ +export function operation(data: T) { + const op = { + withLockContext: () => op, + audit: () => op, + then: ( + onfulfilled?: ((value: { data: T }) => unknown) | null, + onrejected?: ((reason: unknown) => unknown) | null, + ) => Promise.resolve({ data }).then(onfulfilled, onrejected), + } + return op +} + +type SchemaLike = { + build(): { columns: Record } + buildColumnKeyMap?(): Record +} + +export function createMockEncryptionClient() { + const encryptedProps = (table: SchemaLike): string[] => + table.buildColumnKeyMap + ? Object.keys(table.buildColumnKeyMap()) + : Object.keys(table.build().columns) + + const client = { + encrypt: (value: unknown, opts: { column: { getName(): string } }) => + operation(fakeEnvelope(value, opts.column.getName())), + + // v3 filter path: one FFI crossing per (table, column) group. Position- + // stable and envelope-identical to `encrypt`, so every wire assertion holds + // whichever path the builder takes. + bulkEncrypt: ( + payloads: Array<{ plaintext: unknown }>, + opts: { column: { getName(): string } }, + ) => + operation( + payloads.map((p) => ({ + data: fakeEnvelope(p.plaintext, opts.column.getName()), + })), + ), + + // v2 filter path: batch query terms as composite literals + encryptQuery: (terms: Array<{ value: unknown }>) => + operation(terms.map((t) => `("${String(t.value)}")`)), + + encryptModel: (model: Record, table: SchemaLike) => { + const props = encryptedProps(table) + const out: Record = { ...model } + for (const prop of props) { + if (out[prop] != null) out[prop] = fakeEnvelope(out[prop], prop) + } + return operation(out) + }, + + bulkEncryptModels: ( + models: Record[], + table: SchemaLike, + ) => { + const props = encryptedProps(table) + return operation( + models.map((model) => { + const out: Record = { ...model } + for (const prop of props) { + if (out[prop] != null) out[prop] = fakeEnvelope(out[prop], prop) + } + return out + }), + ) + }, + + decryptModel: (model: Record) => { + const out: Record = {} + for (const [key, value] of Object.entries(model)) { + out[key] = isFakeEnvelope(value) ? value.pt : value + } + return operation(out) + }, + + bulkDecryptModels: (models: Record[]) => + operation( + models.map((model) => { + const out: Record = {} + for (const [key, value] of Object.entries(model)) { + out[key] = isFakeEnvelope(value) ? value.pt : value + } + return out + }), + ), + } + + return client as unknown as EncryptionClient +} + +export type RecordedCall = { method: string; args: unknown[] } + +export function createMockSupabase(resultData: unknown = []) { + const calls: RecordedCall[] = [] + // biome-ignore lint/suspicious/noExplicitAny: test double for the supabase query builder + const qb: any = {} + const methods = [ + 'select', + 'insert', + 'update', + 'upsert', + 'delete', + 'eq', + 'neq', + 'gt', + 'gte', + 'lt', + 'lte', + 'like', + 'ilike', + 'contains', + 'is', + 'in', + 'filter', + 'not', + 'or', + 'match', + 'order', + 'limit', + 'range', + 'single', + 'maybeSingle', + 'csv', + 'abortSignal', + 'throwOnError', + ] + for (const method of methods) { + qb[method] = (...args: unknown[]) => { + calls.push({ method, args }) + return qb + } + } + qb.then = ( + onfulfilled?: ((value: unknown) => unknown) | null, + onrejected?: ((reason: unknown) => unknown) | null, + ) => + Promise.resolve({ + data: resultData, + error: null, + count: null, + status: 200, + statusText: 'OK', + }).then(onfulfilled, onrejected) + + const client = { from: (_table: string) => qb } + const callsFor = (method: string) => calls.filter((c) => c.method === method) + + return { client, calls, callsFor } +} diff --git a/packages/stack-supabase/__tests__/supabase-encryption-error.test.ts b/packages/stack-supabase/__tests__/supabase-encryption-error.test.ts new file mode 100644 index 000000000..5154b8c1e --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-encryption-error.test.ts @@ -0,0 +1,165 @@ +import type { EncryptionClient } from '@cipherstash/stack/encryption' +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { EncryptionErrorTypes } from '@cipherstash/stack/errors' +import { + encryptedColumn, + encryptedTable as encryptedTableV2, +} from '@cipherstash/stack/schema' +import { describe, expect, it } from 'vitest' +import { EncryptedQueryBuilderImpl } from '../src/query-builder' +import { EncryptedQueryBuilderV3Impl } from '../src/query-builder-v3' +import { + createMockEncryptionClient, + createMockSupabase, + fakeEnvelope, + operation, +} from './helpers/supabase-mock' + +/** + * Regression coverage for #626: the query builder's catch block used to hardcode + * `encryptionError: undefined`, so the typed `EncryptedSupabaseError.encryptionError` + * field was dead. The v2 tests pin that a genuine encryption failure now threads its + * `EncryptionError` through the shared base `execute()` catch, while a plain + * (non-encryption) throw leaves it unset. The v3 tests cover the dialect's own + * `encryptionFailure` path, which synthesizes an `EncryptionError` for its two + * query-term contract-violation cases (length mismatch, null envelope) that have + * no operation failure to wrap. + */ + +const usersV2 = encryptedTableV2('users', { + email: encryptedColumn('email').freeTextSearch().equality(), +}) + +const usersV3 = encryptedTable('users', { + email: types.TextEq('email'), +}) + +/** A chainable op that resolves to `{ failure }`, like a real failed operation. */ +function failingOperation(failure: { type: string; message: string }) { + const op = { + withLockContext: () => op, + audit: () => op, + then: ( + onfulfilled?: ((value: { failure: typeof failure }) => unknown) | null, + onrejected?: ((reason: unknown) => unknown) | null, + ) => Promise.resolve({ failure }).then(onfulfilled, onrejected), + } + return op +} + +describe('EncryptedSupabaseError.encryptionError (#626)', () => { + it('v2: threads the EncryptionError through on an encryption failure', async () => { + const failure = { + type: EncryptionErrorTypes.EncryptionError, + message: 'zerokms unreachable', + } + const encryptionClient = createMockEncryptionClient() as unknown as Record< + string, + unknown + > + encryptionClient['encryptModel'] = () => failingOperation(failure) + + const { client: supabase } = createMockSupabase() + const builder = new EncryptedQueryBuilderImpl( + 'users', + usersV2, + encryptionClient as unknown as EncryptionClient, + supabase, + ) + + const { data, error } = await builder.insert({ email: 'ada@example.com' }) + + expect(data).toBeNull() + expect(error).not.toBeNull() + expect(error?.encryptionError).toEqual(failure) + expect(error?.encryptionError?.type).toBe( + EncryptionErrorTypes.EncryptionError, + ) + }) + + it('v2: leaves encryptionError unset on a plain (non-encryption) error', async () => { + const encryptionClient = createMockEncryptionClient() + const { client: supabase } = createMockSupabase() + // Make the underlying supabase call throw a non-encryption error: an insert + // with no encrypted columns skips encryption and goes straight to the wire. + supabase.from = () => { + throw new Error('PostgREST is down') + } + + const builder = new EncryptedQueryBuilderImpl( + 'users', + usersV2, + encryptionClient, + supabase, + ) + + const { data, error } = await builder.insert({ id: 1 } as never) + + expect(data).toBeNull() + expect(error?.message).toContain('PostgREST is down') + expect(error?.encryptionError).toBeUndefined() + }) + + it('v3: synthesizes an EncryptionError for a query-term contract violation', async () => { + // The v3 dialect's own `encryptionFailure` path has no operation failure to + // wrap for its contract-violation cases, so it synthesizes an EncryptionError. + // Drive it directly: a two-element `in` list whose bulkEncrypt returns one + // term trips the length-mismatch check. (The base `execute()` threading is + // already covered by the v2 test above; overriding `encryptModel` here would + // only re-run that shared path, not this v3-specific branch.) + const encryptionClient = createMockEncryptionClient() as unknown as { + bulkEncrypt: (...args: unknown[]) => unknown + } + encryptionClient.bulkEncrypt = () => + operation([{ data: fakeEnvelope('ada', 'email') }]) + + const { client: supabase } = createMockSupabase() + const { error, status } = await new EncryptedQueryBuilderV3Impl( + 'users', + usersV3, + encryptionClient as unknown as EncryptionClient, + supabase, + ['id', 'email'], + ) + .select('id') + .in('email', ['ada@example.com', 'grace@example.com']) + + expect(status).toBe(500) + expect(error?.encryptionError?.type).toBe( + EncryptionErrorTypes.EncryptionError, + ) + expect(error?.encryptionError?.message).toMatch( + /1 term(s)? for 2 value(s)?/, + ) + }) + + it('v3: synthesizes an EncryptionError for a null-envelope contract violation', async () => { + // The other no-cause `encryptionFailure` path: a length-matched bulk response + // whose position 0 is a null envelope. Same synthesized-EncryptionError branch + // as the length-mismatch case above, reached from a different call site. + const encryptionClient = createMockEncryptionClient() as unknown as { + bulkEncrypt: (...args: unknown[]) => unknown + } + encryptionClient.bulkEncrypt = () => + operation([{ data: null }, { data: fakeEnvelope('grace', 'email') }]) + + const { client: supabase } = createMockSupabase() + const { error, status } = await new EncryptedQueryBuilderV3Impl( + 'users', + usersV3, + encryptionClient as unknown as EncryptionClient, + supabase, + ['id', 'email'], + ) + .select('id') + .in('email', ['ada@example.com', 'grace@example.com']) + + expect(status).toBe(500) + expect(error?.encryptionError?.type).toBe( + EncryptionErrorTypes.EncryptionError, + ) + expect(error?.encryptionError?.message).toMatch( + /null envelope at position 0/, + ) + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-helpers.test.ts b/packages/stack-supabase/__tests__/supabase-helpers.test.ts new file mode 100644 index 000000000..cb3ef2f88 --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-helpers.test.ts @@ -0,0 +1,581 @@ +import { describe, expect, it } from 'vitest' +import { addJsonbCastsV3, parseOrString, rebuildOrString } from '../src/helpers' +import type { DbPendingOrCondition } from '../src/types' + +// `createdAt` is a renamed property (DB column `created_at`); `email` is a +// property whose name already equals its DB column. +const propToDb = { createdAt: 'created_at', email: 'email' } + +describe('addJsonbCastsV3', () => { + it('aliases a renamed property to its DB name', () => { + expect(addJsonbCastsV3('createdAt', propToDb)).toBe( + 'createdAt:created_at::jsonb', + ) + }) + + it('casts a property whose name equals its DB name in place', () => { + expect(addJsonbCastsV3('email', propToDb)).toBe('email::jsonb') + }) + + it('casts a raw DB name in place, without aliasing', () => { + expect(addJsonbCastsV3('created_at', propToDb)).toBe('created_at::jsonb') + }) + + it('resolves an already-aliased token whose name is a property', () => { + expect(addJsonbCastsV3('e:createdAt', propToDb)).toBe('e:created_at::jsonb') + }) + + it('resolves an already-aliased token whose name is a raw DB name', () => { + expect(addJsonbCastsV3('e:created_at', propToDb)).toBe( + 'e:created_at::jsonb', + ) + }) + + it('leaves an aliased token naming an unknown column untouched', () => { + expect(addJsonbCastsV3('e:other', propToDb)).toBe('e:other') + }) + + it('leaves already-cast tokens untouched', () => { + expect(addJsonbCastsV3('email::text', propToDb)).toBe('email::text') + }) + + it('leaves function calls untouched', () => { + expect(addJsonbCastsV3('count(email)', propToDb)).toBe('count(email)') + }) + + it('leaves foreign-table (dotted) tokens untouched', () => { + expect(addJsonbCastsV3('t.email', propToDb)).toBe('t.email') + }) + + // `lookupDbName`'s `Object.hasOwn` guard. Without it an inherited + // `Object.prototype` member resolves truthy and gets interpolated into the + // emitted select string (e.g. `function Object() { … }::jsonb`). + it('does not resolve a bare Object.prototype key as a property', () => { + expect(addJsonbCastsV3('constructor', propToDb)).toBe('constructor') + }) + + it('does not resolve an Object.prototype key inside an alias', () => { + expect(addJsonbCastsV3('a:toString', propToDb)).toBe('a:toString') + }) + + // Pins the leading-whitespace capture: drop it and ` email` loses its space. + it('maps each token of a multi-column select independently', () => { + expect(addJsonbCastsV3('id, email, createdAt', propToDb)).toBe( + 'id, email::jsonb, createdAt:created_at::jsonb', + ) + }) +}) + +// --------------------------------------------------------------------------- +// .or() operand quoting +// +// Every v3 encrypted operand is `JSON.stringify(envelope)` — dense with double +// quotes and commas. `formatOrValue` wraps a comma-bearing value in quotes but +// never escapes the quotes already inside it, so PostgREST terminates the value +// at the first inner `"`. Pre-existing in v2 (its composite literal also +// carries quotes); v3 makes it certain to fire. +// --------------------------------------------------------------------------- + +const ENVELOPE = '{"v":1,"i":{"t":"users","c":"email"},"c":"ct:abc"}' + +/** `rebuildOrString` takes DB-space conditions; `column` is a branded `DbName`. */ +function cond(column: string, op: string, value: unknown, negate?: boolean) { + return { column, op, value, negate } as unknown as DbPendingOrCondition +} + +describe('rebuildOrString quoting', () => { + it('escapes the double quotes inside a quoted operand', () => { + const out = rebuildOrString([cond('email', 'eq', ENVELOPE)]) + // The operand must be one quoted token whose inner quotes are escaped. + expect(out).toBe( + `email.eq."{\\"v\\":1,\\"i\\":{\\"t\\":\\"users\\",\\"c\\":\\"email\\"},\\"c\\":\\"ct:abc\\"}"`, + ) + }) + + it('escapes a backslash before escaping quotes', () => { + expect(rebuildOrString([cond('a', 'eq', 'x\\y,z')])).toBe('a.eq."x\\\\y,z"') + }) + + it('quotes a value containing a bare double quote even without a comma', () => { + expect(rebuildOrString([cond('a', 'eq', 'he"llo')])).toBe('a.eq."he\\"llo"') + }) + + it('leaves a value with no reserved characters unquoted', () => { + expect(rebuildOrString([cond('a', 'eq', 'plain')])).toBe('a.eq.plain') + }) + + // A brace is structural to PostgREST's own logic-tree parser inside `or=(…)`, + // so an unquoted `a{b` scalar is malformed on the wire — and it desynchronises + // our parser on the way back in. Emit and parse must agree on what is structure. + it('quotes a scalar value containing an opening brace', () => { + expect(rebuildOrString([cond('a', 'eq', 'a{b')])).toBe('a.eq."a{b"') + }) + + it('quotes a scalar value containing a closing brace', () => { + expect(rebuildOrString([cond('a', 'eq', 'a}b')])).toBe('a.eq."a}b"') + }) +}) + +// --------------------------------------------------------------------------- +// `contains` is the ONLY FilterOp that is a supabase-js METHOD name rather than +// a PostgREST operator token. Every other member of the union (`eq`, `in`, +// `like`, `is`, …) spells the same in both. Left untranslated, `rebuildOrString` +// emits `tags.contains.vip`, which PostgREST rejects with PGRST100 +// ("unexpected \"c\" expecting \"not\" or operator"). +// +// Translating the operator alone is not enough: `cs` takes a CONTAINMENT +// literal, not the `(a,b)` list form arrays otherwise get, so `tags.cs.(vip)` +// fails with 22P02 ("malformed array literal"). Both halves are asserted here +// and executed against a real PostgREST in `supabase-v3-pgrest-live.test.ts`. +// --------------------------------------------------------------------------- + +describe('rebuildOrString containment', () => { + it("translates the `contains` FilterOp to PostgREST's `cs` token", () => { + expect(rebuildOrString([cond('tags', 'contains', 'vip')])).toBe( + 'tags.cs.vip', + ) + }) + + it('formats an array operand as an array literal, not an in-list', () => { + expect(rebuildOrString([cond('tags', 'contains', ['vip'])])).toBe( + 'tags.cs.{vip}', + ) + }) + + it('quotes a multi-element array literal, whose comma is reserved', () => { + expect(rebuildOrString([cond('tags', 'contains', ['vip', 'admin'])])).toBe( + 'tags.cs."{vip,admin}"', + ) + }) + + it('quotes an array element that itself contains a comma', () => { + // Inner array-literal quoting, then outer PostgREST quoting of the whole. + expect(rebuildOrString([cond('tags', 'contains', ['with,comma'])])).toBe( + 'tags.cs."{\\"with,comma\\"}"', + ) + }) + + it('formats an object operand as a jsonb literal', () => { + expect(rebuildOrString([cond('meta', 'contains', { a: 1 })])).toBe( + 'meta.cs."{\\"a\\":1}"', + ) + }) + + it('leaves an already-serialized encrypted envelope as a quoted scalar', () => { + // The v3 encrypted operand is `JSON.stringify(envelope)` — a string, not an + // array or object. It must keep taking the scalar quoting path. + expect(rebuildOrString([cond('email', 'contains', ENVELOPE)])).toBe( + `email.cs."{\\"v\\":1,\\"i\\":{\\"t\\":\\"users\\",\\"c\\":\\"email\\"},\\"c\\":\\"ct:abc\\"}"`, + ) + }) + + it('keeps the `cs` token a string-form caller already wrote', () => { + expect(rebuildOrString([cond('tags', 'cs', ['vip', 'admin'])])).toBe( + 'tags.cs."{vip,admin}"', + ) + }) + + it('negates containment as `not.cs`', () => { + expect(rebuildOrString([cond('tags', 'contains', ['vip'], true)])).toBe( + 'tags.not.cs.{vip}', + ) + }) + + it('still renders an `in` array as a parenthesized list', () => { + expect(rebuildOrString([cond('nickname', 'in', ['ada', 'grace'])])).toBe( + 'nickname.in.(ada,grace)', + ) + }) +}) + +describe('parseOrString / rebuildOrString round-trip', () => { + it('round-trips an encrypted JSON envelope operand', () => { + const conditions = [ + { column: 'email', op: 'eq', negate: false, value: ENVELOPE }, + ] + expect( + parseOrString( + rebuildOrString(conditions.map((c) => cond(c.column, c.op, c.value))), + ), + ).toEqual(conditions) + }) + + it('round-trips a value carrying backslashes and quotes', () => { + const conditions = [ + { column: 'a', op: 'eq', negate: false, value: 'x\\"y,z' }, + ] + expect( + parseOrString( + rebuildOrString(conditions.map((c) => cond(c.column, c.op, c.value))), + ), + ).toEqual(conditions) + }) + + it('does not split on a comma inside a quoted operand', () => { + const s = rebuildOrString([ + cond('email', 'eq', ENVELOPE), + cond('id', 'eq', '7'), + ]) + const parsed = parseOrString(s) + expect(parsed).toHaveLength(2) + expect(parsed[0].value).toBe(ENVELOPE) + expect(parsed[1].value).toBe('7') + }) + + // The emit side must never produce a string its own parser mis-reads. A scalar + // brace was the one character that escaped quoting, so rebuild → parse dropped + // the condition behind it. + it.each([ + 'a{b', + 'a}b', + 'a(b', + 'a)b', + ])('round-trips a scalar value containing %s', (value) => { + const conditions = [ + { column: 'note', op: 'eq', negate: false, value }, + { column: 'id', op: 'eq', negate: false, value: '7' }, + ] + const s = rebuildOrString( + conditions.map((c) => cond(c.column, c.op, c.value)), + ) + expect(parseOrString(s)).toEqual(conditions) + }) +}) + +// --------------------------------------------------------------------------- +// PostgREST negation inside .or() +// +// The parser split on the first two dots, so `col.not.in.(a,b)` yielded +// `{ op: 'not', value: 'in.(a,b)' }`. On a plaintext column that round-tripped +// by accident (rebuild re-joins the pieces verbatim). On an ENCRYPTED column the +// literal string `in.(a,b)` was encrypted as one plaintext, producing a filter +// that silently matched nothing. +// --------------------------------------------------------------------------- + +// A containment literal carries top-level commas inside its braces +// (`tags.cs.{vip,admin}`). PostgREST's own logic-tree parser tracks those +// braces; ours must too, or the condition is split mid-literal into +// `tags.cs.{vip` plus a fragment `admin}` that has no dot and is dropped +// entirely — a filter that silently matches the wrong rows. Only or-strings +// that also reference an encrypted column are rebuilt from the parse, so this +// corrupts precisely the mixed encrypted/plaintext case. +describe('parseOrString containment literals', () => { + it('does not split on a comma inside an array literal', () => { + expect(parseOrString('note.eq.hello,tags.cs.{vip,admin}')).toEqual([ + { column: 'note', op: 'eq', negate: false, value: 'hello' }, + { column: 'tags', op: 'cs', negate: false, value: '{vip,admin}' }, + ]) + }) + + it('does not split on a comma inside a jsonb literal', () => { + expect(parseOrString('meta.cs.{"a":1,"b":2},note.eq.x')).toEqual([ + { column: 'meta', op: 'cs', negate: false, value: '{"a":1,"b":2}' }, + { column: 'note', op: 'eq', negate: false, value: 'x' }, + ]) + }) + + it('round-trips a plaintext containment literal through rebuild', () => { + const parsed = parseOrString('tags.cs.{vip,admin}') + expect(rebuildOrString(parsed as DbPendingOrCondition[])).toBe( + 'tags.cs."{vip,admin}"', + ) + }) +}) + +// A quoted operand is opaque at EVERY depth, and a stray brace or paren in an +// unquoted value is a literal character, not structure. Tracking quotes only at +// depth 0 let a `}` inside a quoted array element close the literal early; an +// unmatched `}` in a plain value drove the depth counter negative, after which no +// top-level comma ever split again. Both silently absorb the following condition +// into the preceding operand — and only or-strings that also reference an +// encrypted column are rebuilt from the parse, so it corrupts precisely the +// mixed encrypted/plaintext case. +describe('parseOrString structural characters inside values', () => { + it('does not close an array literal on a brace inside a quoted element', () => { + expect(parseOrString('tags.cs.{"a}b"},email.eq.secret')).toEqual([ + { column: 'tags', op: 'cs', negate: false, value: '{"a}b"}' }, + { column: 'email', op: 'eq', negate: false, value: 'secret' }, + ]) + }) + + it('does not close a jsonb literal on a brace inside a quoted value', () => { + expect(parseOrString('meta.cs.{"a":"v}"},id.eq.1')).toEqual([ + { column: 'meta', op: 'cs', negate: false, value: '{"a":"v}"}' }, + { column: 'id', op: 'eq', negate: false, value: '1' }, + ]) + }) + + // Every structural character, quoted as a jsonb VALUE, with the encrypted + // column ahead of the literal and a plaintext condition behind it — the shape + // that actually reaches `rebuildOrString`, since the encrypted `email` is what + // forces the group to be rebuilt rather than forwarded verbatim. + it.each([ + '}', + '{', + ')', + '(', + ])('keeps a quoted %s inside a jsonb literal out of the depth count', (char) => { + expect( + parseOrString(`email.eq.x,meta.cs.{"a":"${char}"},note.eq.y`), + ).toEqual([ + { column: 'email', op: 'eq', negate: false, value: 'x' }, + { column: 'meta', op: 'cs', negate: false, value: `{"a":"${char}"}` }, + { column: 'note', op: 'eq', negate: false, value: 'y' }, + ]) + }) + + it('keeps an escaped quote inside a jsonb value opaque', () => { + // `\"` must not close the element, or the `}` behind it decrements depth. + expect(parseOrString('a.eq.1,meta.cs.{"a":"\\"}"},b.eq.2')).toHaveLength(3) + }) + + it('splits after an unmatched brace in an unquoted value', () => { + // `}` is not a PostgREST reserved character, so `a}b` is a valid unquoted + // scalar operand. + expect(parseOrString('nickname.eq.a}b,id.eq.1')).toEqual([ + { column: 'nickname', op: 'eq', negate: false, value: 'a}b' }, + { column: 'id', op: 'eq', negate: false, value: '1' }, + ]) + }) + + it('splits after an unmatched paren in an unquoted value', () => { + expect(parseOrString('a.eq.x),b.eq.y')).toEqual([ + { column: 'a', op: 'eq', negate: false, value: 'x)' }, + { column: 'b', op: 'eq', negate: false, value: 'y' }, + ]) + }) + + // The mirror image of the two cases above, and the one the depth floor cannot + // catch: an unmatched OPENING brace or paren leaves `depth` above zero for the + // rest of the string, so no later comma ever splits. Every following condition + // is swallowed into this operand. With a plaintext column first the group is + // then forwarded VERBATIM (nothing looks encrypted), so PostgREST runs the + // swallowed `email.eq.ada` with a plaintext operand against a ciphertext column. + it('splits after an unmatched opening brace in an unquoted value', () => { + expect(parseOrString('note.eq.a{b,email.eq.ada')).toEqual([ + { column: 'note', op: 'eq', negate: false, value: 'a{b' }, + { column: 'email', op: 'eq', negate: false, value: 'ada' }, + ]) + }) + + it('splits after an unmatched opening paren in an unquoted value', () => { + expect(parseOrString('note.eq.a(b,email.eq.ada')).toEqual([ + { column: 'note', op: 'eq', negate: false, value: 'a(b' }, + { column: 'email', op: 'eq', negate: false, value: 'ada' }, + ]) + }) + + // A stray opener must not cost the or-string its REAL containment literals. + // Discarding the depth pass wholesale on an unbalanced count re-splits inside + // `{vip,admin}`, and the dotless `admin}` fragment is then dropped by + // `parseOrString` — the same silent condition loss, moved one operand along. + // A structural brace opens a group or an operand; anywhere else it is data. + it('keeps a sibling array literal intact past a stray opening brace', () => { + expect(parseOrString('note.eq.a{b,tags.cs.{vip,admin}')).toEqual([ + { column: 'note', op: 'eq', negate: false, value: 'a{b' }, + { column: 'tags', op: 'cs', negate: false, value: '{vip,admin}' }, + ]) + }) + + it('keeps an array literal intact when the stray opener follows it', () => { + expect(parseOrString('tags.cs.{vip,admin},note.eq.a{b')).toEqual([ + { column: 'tags', op: 'cs', negate: false, value: '{vip,admin}' }, + { column: 'note', op: 'eq', negate: false, value: 'a{b' }, + ]) + }) + + it('keeps a sibling jsonb literal intact past a stray opening brace', () => { + expect(parseOrString('note.eq.a{b,meta.cs.{"a":1,"b":2}')).toEqual([ + { column: 'note', op: 'eq', negate: false, value: 'a{b' }, + { column: 'meta', op: 'cs', negate: false, value: '{"a":1,"b":2}' }, + ]) + }) + + it('keeps a sibling array literal intact past a stray opening paren', () => { + expect(parseOrString('note.eq.a(b,tags.cs.{vip,admin}')).toEqual([ + { column: 'note', op: 'eq', negate: false, value: 'a(b' }, + { column: 'tags', op: 'cs', negate: false, value: '{vip,admin}' }, + ]) + }) + + // The boundary rule reads any `{` after a dot as an operand opener, so a + // scalar carrying an in-value dot still fools it. The unbalanced-depth + // re-split is what recovers this one; both mechanisms are load-bearing. + it('recovers a scalar whose brace follows an in-value dot', () => { + expect(parseOrString('x.eq.a.{b,y.eq.1')).toEqual([ + { column: 'x', op: 'eq', negate: false, value: 'a.{b' }, + { column: 'y', op: 'eq', negate: false, value: '1' }, + ]) + }) + + it('treats and/or group parens as structure', () => { + expect(parseOrString('and(a.eq.1,b.eq.2),c.eq.3')).toHaveLength(2) + expect(parseOrString('not.and(a.eq.1,b.eq.2),c.eq.3')).toHaveLength(2) + expect(parseOrString('and(a.eq.1,or(b.eq.2,c.eq.3)),d.eq.4')).toHaveLength( + 2, + ) + }) +}) + +// An `in`-list element is quoted exactly like any other operand, so the list must +// be split on top-level commas and each element unquoted. Splitting the raw +// string on every comma tore `("a,b",c)` into three fragments and left the quotes +// embedded in them — on an encrypted column each fragment is encrypted as its own +// term, so the intended element never matches. +describe('parseOrString in-list elements', () => { + it('does not split on a comma inside a quoted element', () => { + expect(parseOrString('email.in.("a,b",c)')).toEqual([ + { column: 'email', op: 'in', negate: false, value: ['a,b', 'c'] }, + ]) + }) + + it('unescapes a quoted element', () => { + expect(parseOrString('a.in.("x\\"y",z)')).toEqual([ + { column: 'a', op: 'in', negate: false, value: ['x"y', 'z'] }, + ]) + }) + + it('round-trips a comma-bearing element through rebuild', () => { + const s = 'name.in.("Doe, John",Smith)' + expect(rebuildOrString(parseOrString(s) as DbPendingOrCondition[])).toBe(s) + }) + + it('round-trips an encrypted envelope element', () => { + const parsed = parseOrString( + rebuildOrString([cond('email', 'in', [ENVELOPE, 'x'])]), + ) + expect(parsed).toEqual([ + { column: 'email', op: 'in', negate: false, value: [ENVELOPE, 'x'] }, + ]) + }) + + it('splits a negated list on top-level commas only', () => { + expect(parseOrString('email.not.in.("a,b",c)')).toEqual([ + { column: 'email', op: 'in', negate: true, value: ['a,b', 'c'] }, + ]) + }) + + // Only the operators whose operand PostgREST delimits with parens take a list. + // A parenthesized operand anywhere else is a scalar that happens to start with + // `(`: parsed as an array, an encrypted `eq` operand is encrypted as a JS array + // rather than the intended string, and the filter matches nothing. + it('does not read a parenthesized scalar as a list for a scalar operator', () => { + expect(parseOrString('email.eq.(foo)')).toEqual([ + { column: 'email', op: 'eq', negate: false, value: '(foo)' }, + ]) + }) + + // The range operators take a paren-delimited operand too. Excluding them would + // re-emit `period.ov.(1,10)` as a quoted scalar — a wire-format change on a + // plaintext column that merely shares an `.or()` with an encrypted one. + it.each([ + 'ov', + 'sl', + 'sr', + 'nxr', + 'nxl', + 'adj', + ])('round-trips a paren-delimited %s operand', (op) => { + const s = `period.${op}.(1,10)` + expect(parseOrString(s)).toEqual([ + { column: 'period', op, negate: false, value: ['1', '10'] }, + ]) + expect(rebuildOrString(parseOrString(s) as DbPendingOrCondition[])).toBe(s) + }) +}) + +// PostgREST reads a bare `null` / `true` / `false` operand as the SQL value, not +// as the string spelling it. A string operand that happens to spell one must be +// quoted, or `name.eq.null` compares against SQL NULL and matches nothing. +describe('rebuildOrString reserved words', () => { + it.each(['null', 'true', 'false'])('quotes the string %s', (word) => { + expect(rebuildOrString([cond('name', 'eq', word)])).toBe( + `name.eq."${word}"`, + ) + }) + + it('leaves the SQL values unquoted', () => { + expect(rebuildOrString([cond('a', 'is', null)])).toBe('a.is.null') + expect(rebuildOrString([cond('a', 'is', true)])).toBe('a.is.true') + expect(rebuildOrString([cond('a', 'is', false)])).toBe('a.is.false') + }) + + it('quotes a reserved word inside an in-list', () => { + expect(rebuildOrString([cond('a', 'in', ['null', 'x'])])).toBe( + 'a.in.("null",x)', + ) + }) +}) + +describe('parseOrString negation', () => { + it('lifts a not. prefix off the operator', () => { + expect(parseOrString('nickname.not.eq.ada')).toEqual([ + { column: 'nickname', op: 'eq', negate: true, value: 'ada' }, + ]) + }) + + it('parses a negated in-list as a real list, not a literal string', () => { + expect(parseOrString('nickname.not.in.(ada,grace)')).toEqual([ + { column: 'nickname', op: 'in', negate: true, value: ['ada', 'grace'] }, + ]) + }) + + it('parses not.is.null', () => { + expect(parseOrString('email.not.is.null')).toEqual([ + { column: 'email', op: 'is', negate: true, value: null }, + ]) + }) + + it('leaves a non-negated condition unnegated', () => { + expect(parseOrString('nickname.in.(ada,grace)')).toEqual([ + { column: 'nickname', op: 'in', negate: false, value: ['ada', 'grace'] }, + ]) + }) + + it('does not mistake a column or value named "not" for the prefix', () => { + expect(parseOrString('not.eq.ada')).toEqual([ + { column: 'not', op: 'eq', negate: false, value: 'ada' }, + ]) + expect(parseOrString('nickname.eq.not')).toEqual([ + { column: 'nickname', op: 'eq', negate: false, value: 'not' }, + ]) + }) + + it('does not swallow a condition whose not. prefix has no operator', () => { + // `col.not.` is malformed PostgREST. Consuming the prefix would leave + // no operator, and the condition would be silently DROPPED from the or-string + // — quietly widening the result set. Pass it through so PostgREST rejects it. + expect(parseOrString('nickname.not.ada')).toEqual([ + { column: 'nickname', op: 'not', negate: false, value: 'ada' }, + ]) + expect( + rebuildOrString( + parseOrString('nickname.not.ada') as DbPendingOrCondition[], + ), + ).toBe('nickname.not.ada') + }) +}) + +describe('rebuildOrString negation', () => { + it('re-emits the not. prefix', () => { + expect(rebuildOrString([cond('nickname', 'eq', 'ada', true)])).toBe( + 'nickname.not.eq.ada', + ) + }) + + it('round-trips a negated in-list through parse → rebuild', () => { + const parsed = parseOrString('nickname.not.in.(ada,grace)') + expect(rebuildOrString(parsed as DbPendingOrCondition[])).toBe( + 'nickname.not.in.(ada,grace)', + ) + }) + + it('omits the prefix when negate is false or absent', () => { + expect(rebuildOrString([cond('nickname', 'eq', 'ada', false)])).toBe( + 'nickname.eq.ada', + ) + expect(rebuildOrString([cond('nickname', 'eq', 'ada')])).toBe( + 'nickname.eq.ada', + ) + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-introspect.test.ts b/packages/stack-supabase/__tests__/supabase-introspect.test.ts new file mode 100644 index 000000000..9259da720 --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-introspect.test.ts @@ -0,0 +1,220 @@ +import fc from 'fast-check' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { groupIntrospectionRows, loadPg } from '../src/introspect' + +describe('groupIntrospectionRows', () => { + it('groups rows by table, preserving row order as column order', () => { + const result = groupIntrospectionRows([ + { table_name: 'users', column_name: 'id', domain_name: null }, + { + table_name: 'users', + column_name: 'email', + domain_name: 'eql_v3_text_search', + }, + { table_name: 'users', column_name: 'note', domain_name: null }, + { table_name: 'orders', column_name: 'id', domain_name: null }, + { + table_name: 'orders', + column_name: 'total', + domain_name: 'eql_v3_integer_ord', + }, + ]) + + expect(result).toEqual([ + { + tableName: 'users', + columns: [ + { columnName: 'id', domainName: null }, + { columnName: 'email', domainName: 'eql_v3_text_search' }, + { columnName: 'note', domainName: null }, + ], + }, + { + tableName: 'orders', + columns: [ + { columnName: 'id', domainName: null }, + { columnName: 'total', domainName: 'eql_v3_integer_ord' }, + ], + }, + ]) + }) + + it('returns an empty array for no rows', () => { + expect(groupIntrospectionRows([])).toEqual([]) + }) + + it('PROPERTY: preserves total column count, first-seen table order, and domains', () => { + const rowArb = fc.record({ + table_name: fc.constantFrom('a', 'b', 'c'), + column_name: fc.string(), + domain_name: fc.option(fc.string(), { nil: null }), + }) + fc.assert( + fc.property(fc.array(rowArb), (rows) => { + const grouped = groupIntrospectionRows(rows) + // (1) Column count is preserved. + const total = grouped.reduce((n, t) => n + t.columns.length, 0) + expect(total).toBe(rows.length) + // (2) Table order is first-seen order of the input. + const firstSeen: string[] = [] + for (const r of rows) { + if (!firstSeen.includes(r.table_name)) firstSeen.push(r.table_name) + } + expect(grouped.map((t) => t.tableName)).toEqual(firstSeen) + // (3) Per-table column names+domains match the input rows in order. + for (const t of grouped) { + const expected = rows + .filter((r) => r.table_name === t.tableName) + .map((r) => ({ + columnName: r.column_name, + domainName: r.domain_name, + })) + expect(t.columns).toEqual(expected) + } + }), + ) + }) +}) + +describe('introspect happy path', () => { + afterEach(() => vi.resetModules()) + + it('issues both queries, builds the domains, and closes the connection', async () => { + const end = vi.fn(() => Promise.resolve()) + const queries: Array<{ sql: string; params?: unknown[] }> = [] + + vi.doMock('pg', () => { + class Client { + connect() { + return Promise.resolve() + } + end = end + query(sql: string, params?: unknown[]) { + queries.push({ sql, params }) + // The unmodelled query is the parameterised one. + return Promise.resolve({ + rows: params + ? [ + { + table_name: 'users', + column_name: 'legacy', + domain_name: 'unsupported_domain', + }, + ] + : [ + { table_name: 'users', column_name: 'id', domain_name: null }, + { + table_name: 'users', + column_name: 'email', + domain_name: 'eql_v3_text_search', + }, + ], + }) + } + } + return { default: { Client } } + }) + + const { introspect } = await import('../src/introspect') + const { tables, unmodelled } = await introspect('postgres://ok') + + expect(queries).toHaveLength(2) + // The registry IS the query parameter — it must be pushed into Postgres, + // not re-derived client-side. + const parameterised = queries.find((q) => q.params)! + expect(parameterised.params?.[0]).toContain('eql_v3_text_search') + + expect(tables).toEqual([ + { + tableName: 'users', + columns: [ + { columnName: 'id', domainName: null }, + { columnName: 'email', domainName: 'eql_v3_text_search' }, + ], + }, + ]) + expect(unmodelled.get('users')).toEqual([ + { columnName: 'legacy', domainName: 'unsupported_domain' }, + ]) + // A leaked connection is invisible to every other assertion here. + expect(end).toHaveBeenCalledTimes(1) + + vi.doUnmock('pg') + }) + + it('closes the connection when a query throws', async () => { + const end = vi.fn(() => Promise.resolve()) + + vi.doMock('pg', () => { + class Client { + connect() { + return Promise.resolve() + } + end = end + query() { + return Promise.reject(new Error('relation does not exist')) + } + } + return { default: { Client } } + }) + + const { introspect } = await import('../src/introspect') + await expect(introspect('postgres://ok')).rejects.toThrow( + 'relation does not exist', + ) + expect(end).toHaveBeenCalledTimes(1) + + vi.doUnmock('pg') + }) +}) + +describe('introspect connection error handling', () => { + afterEach(() => vi.resetModules()) + + it('surfaces the connect error, not a failing end()', async () => { + vi.doMock('pg', () => { + class Client { + connect() { + return Promise.reject(new Error('ECONNREFUSED')) + } + end() { + // A throwing end() must NOT replace the connect error. + return Promise.reject(new Error('end failed')) + } + query() { + return Promise.resolve({ rows: [] }) + } + } + return { default: { Client } } + }) + + const { introspect } = await import('../src/introspect') + await expect(introspect('postgres://unreachable')).rejects.toThrow( + 'ECONNREFUSED', + ) + vi.doUnmock('pg') + }) +}) + +describe('loadPg', () => { + const failingImport = (err: unknown) => () => Promise.reject(err) + + for (const code of ['ERR_MODULE_NOT_FOUND', 'MODULE_NOT_FOUND']) { + it(`remaps a missing optional \`pg\` peer (${code}) to an install message`, async () => { + const err = Object.assign(new Error("Cannot find package 'pg'"), { code }) + + await expect(loadPg(failingImport(err))).rejects.toThrow( + /'pg' is not installed/, + ) + await expect(loadPg(failingImport(err))).rejects.toHaveProperty( + 'cause', + err, + ) + }) + } + + it('does not swallow an unrelated module-load failure', async () => { + const err = new Error('boom: pg self-check failed') + await expect(loadPg(failingImport(err))).rejects.toBe(err) + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-schema-builder.test.ts b/packages/stack-supabase/__tests__/supabase-schema-builder.test.ts new file mode 100644 index 000000000..006588bc8 --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-schema-builder.test.ts @@ -0,0 +1,241 @@ +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { describe, expect, it } from 'vitest' +import type { IntrospectionResult } from '../src/introspect' +import { groupUnmodelledRows } from '../src/introspect' +import { mergeDeclaredTables, synthesizeTables } from '../src/schema-builder' + +const introspection: IntrospectionResult = [ + { + tableName: 'users', + columns: [ + { columnName: 'id', domainName: null }, + { columnName: 'email', domainName: 'eql_v3_text_search' }, + { columnName: 'amount', domainName: 'eql_v3_integer_ord' }, + { columnName: 'note', domainName: null }, + { columnName: 'weird', domainName: 'not_a_domain' }, // unknown → plaintext + ], + }, +] + +describe('synthesizeTables', () => { + it('builds an EncryptedTable with only the recognised domain columns', () => { + const { tables } = synthesizeTables(introspection) + const users = tables.get('users') + expect(users).toBeDefined() + expect(Object.keys(users!.columnBuilders).sort()).toEqual([ + 'amount', + 'email', + ]) + }) + + it('records the FULL column list (encrypted + plaintext) for select(*)', () => { + const { allColumns } = synthesizeTables(introspection) + expect(allColumns.get('users')).toEqual([ + 'id', + 'email', + 'amount', + 'note', + 'weird', + ]) + }) + + it('synthesizes a domain column byte-identically to a declared column', () => { + const { tables } = synthesizeTables(introspection) + const synthesized = tables.get('users')!.build() + const declared = encryptedTable('users', { + email: types.TextSearch('email'), + amount: types.IntegerOrd('amount'), + }).build() + expect(synthesized.columns.email).toEqual(declared.columns.email) + expect(synthesized.columns.amount).toEqual(declared.columns.amount) + }) + + it('treats an Object.prototype-named domain as plaintext, not a domain', () => { + // `DOMAIN_REGISTRY['constructor']` would be truthy on a plain object; the + // null prototype + Object.hasOwn guard keep this column plaintext. + const prototypeNamed: IntrospectionResult = [ + { + tableName: 'weird', + columns: [ + { columnName: 'a', domainName: 'constructor' }, + { columnName: 'b', domainName: '__proto__' }, + { columnName: 'c', domainName: 'toString' }, + ], + }, + ] + const { tables, allColumns } = synthesizeTables(prototypeNamed) + expect(Object.keys(tables.get('weird')!.columnBuilders)).toEqual([]) + expect(allColumns.get('weird')).toEqual(['a', 'b', 'c']) + }) + + // A DB column may legally be named `__proto__`; `encryptedTable()` rejects + // such names as JS properties, but nothing constrains the database. On a plain + // object literal, `builders['__proto__'] = builder` reparents the object + // instead of adding an own key, so the column disappears — it would then be + // treated as a plaintext passthrough and its ciphertext returned undecrypted + // (`decryptModel` skips columns absent from the encrypt config). + const protoColumn: IntrospectionResult = [ + { + tableName: 'users', + columns: [ + { columnName: '__proto__', domainName: 'eql_v3_text_search' }, + { columnName: 'email', domainName: 'eql_v3_text_search' }, + ], + }, + ] + + it('keeps a column literally named __proto__ as an own builder key', () => { + const { tables } = synthesizeTables(protoColumn) + const builders = tables.get('users')!.columnBuilders + + expect(Object.hasOwn(builders, '__proto__')).toBe(true) + expect(Object.keys(builders).sort()).toEqual(['__proto__', 'email']) + }) + + it('registers a __proto__ column in the encrypt config, not on the prototype', () => { + const { columns } = synthesizeTables(protoColumn) + .tables.get('users')! + .build() + + // The load-bearing assertion: absent from the config, the column is a + // plaintext passthrough and reads return raw ciphertext. + expect(Object.hasOwn(columns, '__proto__')).toBe(true) + expect(Object.keys(columns).sort()).toEqual(['__proto__', 'email']) + }) +}) + +describe('mergeDeclaredTables', () => { + // The merge copies synthesized builders across by DB column name. Only the + // SYNTHESIZED side can carry `__proto__` — `encryptedTable()` rejects it as a + // declared key (`isReservedTableKey`) — so this is the one path that can + // reparent the merge target and drop the column from the encrypt config. + it('copies a synthesized __proto__ column as an own key', () => { + const protoIntrospection: IntrospectionResult = [ + { + tableName: 'users', + columns: [ + { columnName: '__proto__', domainName: 'eql_v3_text_search' }, + { columnName: 'email', domainName: 'eql_v3_text_search' }, + ], + }, + ] + const synth = synthesizeTables(protoIntrospection) + const declaredTable = encryptedTable('users', { + email: types.TextSearch('email'), + }) + + const merged = mergeDeclaredTables(synth, { users: declaredTable }) + const builders = merged.tables.get('users')!.columnBuilders + + expect(Object.hasOwn(builders, '__proto__')).toBe(true) + expect(Object.keys(builders).sort()).toEqual(['__proto__', 'email']) + }) + + it('keeps the declared builder instance over the synthesized one', () => { + const synth = synthesizeTables(introspection) + const declaredTable = encryptedTable('users', { + email: types.TextSearch('email'), + }) + const merged = mergeDeclaredTables(synth, { users: declaredTable }) + const mergedTable = merged.tables.get('users')! + + // A declared column and its synthesized twin build byte-identically (see + // above), so instance identity is the only observable proof that the + // declared builder is the one that survived the merge. + expect(mergedTable.columnBuilders.email).toBe( + declaredTable.columnBuilders.email, + ) + expect(mergedTable.build().columns.amount).toBeDefined() + expect(merged.allColumns.get('users')).toEqual( + synth.allColumns.get('users'), + ) + }) + + it('preserves a declared property→DB-name rename', () => { + const renamed: IntrospectionResult = [ + { + tableName: 'events', + columns: [ + { columnName: 'id', domainName: null }, + { columnName: 'created_on', domainName: 'eql_v3_timestamp_ord' }, + ], + }, + ] + const synth = synthesizeTables(renamed) + const declaredTable = encryptedTable('events', { + createdAt: types.TimestampOrd('created_on'), + }) + const merged = mergeDeclaredTables(synth, { events: declaredTable }) + const table = merged.tables.get('events')! + expect(table.buildColumnKeyMap()).toEqual({ createdAt: 'created_on' }) + expect(Object.keys(table.columnBuilders)).toEqual(['createdAt']) + }) + + it('merges a declared table absent from introspection as declared-only', () => { + // Unreachable through `encryptedSupabaseV3` — `verifyDeclaredSchemas` throws + // on an absent table before the merge runs — but `mergeDeclaredTables` is + // exported, so the `if (synthesized)` false arm is reachable by any other + // caller and must not read through to a stale table or throw. + const synth = synthesizeTables(introspection) + const declaredTable = encryptedTable('orders', { + total: types.IntegerOrd('total'), + }) + const merged = mergeDeclaredTables(synth, { orders: declaredTable }) + + expect(Object.keys(merged.tables.get('orders')!.columnBuilders)).toEqual([ + 'total', + ]) + // The absent table contributes no `allColumns`, so `select('*')` on it + // still throws rather than silently selecting nothing. + expect(merged.allColumns.get('orders')).toBeUndefined() + // The introspected table is untouched. + expect( + Object.keys(merged.tables.get('users')!.columnBuilders).sort(), + ).toEqual(['amount', 'email']) + }) +}) + +// The three-way classification (plaintext / modelled / unmodelled) moved into +// `UNMODELLED_COLUMNS_QUERY`'s predicate, so it is proven against live Postgres +// in `integration/supabase/introspect.integration.test.ts`, not here. What remains client-side is +// the grouping — and, load-bearing, the fact that `synthesizeTables` treats an +// unmodelled column as plaintext (covered above): that is exactly why the +// `from()` guard must be unconditional. +describe('groupUnmodelledRows', () => { + it('groups rows by table name, preserving row order', () => { + expect( + groupUnmodelledRows([ + { + table_name: 'metrics', + column_name: 'score', + domain_name: 'eql_v3_integer_ord_ope', + }, + { + table_name: 'audit', + column_name: 'payload', + domain_name: 'eql_v3_json', + }, + { + table_name: 'metrics', + column_name: 'bucket', + domain_name: 'eql_v3_text_ord_ope', + }, + ]), + ).toEqual( + new Map([ + [ + 'metrics', + [ + { columnName: 'score', domainName: 'eql_v3_integer_ord_ope' }, + { columnName: 'bucket', domainName: 'eql_v3_text_ord_ope' }, + ], + ], + ['audit', [{ columnName: 'payload', domainName: 'eql_v3_json' }]], + ]), + ) + }) + + it('returns an empty map when nothing is unmodelled', () => { + expect(groupUnmodelledRows([]).size).toBe(0) + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-v3-builder.test.ts b/packages/stack-supabase/__tests__/supabase-v3-builder.test.ts new file mode 100644 index 000000000..48391c697 --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-v3-builder.test.ts @@ -0,0 +1,1970 @@ +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { + encryptedColumn, + encryptedTable as encryptedTableV2, +} from '@cipherstash/stack/schema' +import { describe, expect, it, vi } from 'vitest' +import { encryptedSupabase } from '../src/index.js' +import { EncryptedQueryBuilderV3Impl } from '../src/query-builder-v3' +import { + createMockEncryptionClient, + createMockSupabase, + fakeEnvelope, + isFakeEnvelope, + operation, +} from './helpers/supabase-mock' + +// --------------------------------------------------------------------------- +// Schemas +// --------------------------------------------------------------------------- + +const users = encryptedTable('users', { + email: types.TextSearch('email'), + nickname: types.TextEq('nickname'), + amount: types.IntegerOrd('amount'), + createdAt: types.TimestampOrd('created_at'), + active: types.Boolean('active'), + // MATCH_ONLY: freeTextSearch WITHOUT equality. The only fixture column that + // can distinguish a correct op→queryType mapping from the `equality` default. + bio: types.TextMatch('bio'), +}) + +const usersV2 = encryptedTableV2('users', { + email: encryptedColumn('email').freeTextSearch().equality(), + age: encryptedColumn('age').dataType('number').equality().orderAndRange(), +}) + +// DB column names as introspection would report them (id/note are plaintext). +const USERS_ALL_COLUMNS = [ + 'id', + 'email', + 'nickname', + 'amount', + 'created_at', + 'active', + 'bio', + 'note', +] + +// `encryptedSupabaseV3` is now an async, DB-introspecting factory, so the wire +// tests construct the v3 builder directly. The declared `users` table is kept +// (not a synthesized one) because the `createdAt:created_at::jsonb` assertions +// are inherently about a property→DB rename that a synthesized table — where +// property == DB name — cannot express. `supabase-schema-builder.test.ts` +// proves synthesized ≡ declared byte-for-byte. +function v3Instance(resultData: unknown = []) { + const supabase = createMockSupabase(resultData) + const encryptionClient = createMockEncryptionClient() + const es = { + from(tableName: string, table: typeof users) { + return new EncryptedQueryBuilderV3Impl( + tableName, + table, + encryptionClient, + supabase.client, + USERS_ALL_COLUMNS, + ) + }, + } + return { es, supabase } +} + +/** + * Extract the operand from an emitted `.or()` token and undo PostgREST's + * quoting, exactly as PostgREST does server-side. + * + * Asserts the inner quotes ARE escaped before unescaping: an unescaped operand + * would be truncated at its first `"` by PostgREST, so a test that merely + * `JSON.parse`d the raw slice would pass on a filter the database rejects. + */ +function orOperand(emitted: string, prefix: string): string { + const quoted = emitted.slice(prefix.length) + expect(quoted.startsWith('"') && quoted.endsWith('"')).toBe(true) + const inner = quoted.slice(1, -1) + expect(inner).toContain('\\"') + return inner.replace(/\\(.)/g, '$1') +} + +// --------------------------------------------------------------------------- +// v3 dialect +// --------------------------------------------------------------------------- + +describe('encryptedSupabaseV3 wire encoding', () => { + // The mutation model is rebuilt by assigning into a fresh object keyed by DB + // column name — `out[dbNameFor(key)] = value`. A DB column named `__proto__` + // (legal via a quoted identifier; reachable here as a rename target, since + // `isReservedTableKey` guards the JS property, not the DB name) would invoke + // the inherited `__proto__` SETTER on a plain object, creating no own key and + // silently sending an empty insert body. + it('keys a mutation on a DB column named __proto__ as an own key', async () => { + const supabase = createMockSupabase() + const secrets = encryptedTable('secrets', { + secret: types.TextSearch('__proto__'), + }) + const builder = new EncryptedQueryBuilderV3Impl( + 'secrets', + secrets, + createMockEncryptionClient(), + supabase.client, + null, + ) + + await builder.insert({ secret: 'x' }) + + const body = supabase.callsFor('insert')[0].args[0] as Record< + string, + unknown + > + expect(Object.hasOwn(body, '__proto__')).toBe(true) + expect(Object.keys(body)).toEqual(['__proto__']) + expect(isFakeEnvelope((body as { __proto__: unknown }).__proto__)).toBe( + true, + ) + }) + + it('inserts the raw encrypted payload keyed by DB column name (no composite wrap)', async () => { + const { es, supabase } = v3Instance() + + const createdAt = new Date('2026-01-02T03:04:05.000Z') + await es + .from('users', users) + .insert({ email: 'a@b.com', createdAt, note: 'plain' }) + + const [insert] = supabase.callsFor('insert') + expect(insert).toBeDefined() + const body = insert.args[0] as Record + + // Property createdAt lands in DB column created_at + expect(Object.keys(body).sort()).toEqual(['created_at', 'email', 'note']) + // Raw envelope — NOT v2's `{ data: ... }` composite wrap + expect(isFakeEnvelope(body.email)).toBe(true) + expect((body.email as Record).data).toBeUndefined() + expect(isFakeEnvelope(body.created_at)).toBe(true) + expect(body.note).toBe('plain') + }) + + it('bulk-inserts raw encrypted payloads keyed by DB column name', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .insert([{ email: 'a@b.com' }, { email: 'b@c.com' }]) + + const [insert] = supabase.callsFor('insert') + const body = insert.args[0] as Record[] + expect(body).toHaveLength(2) + expect(isFakeEnvelope(body[0].email)).toBe(true) + expect(isFakeEnvelope(body[1].email)).toBe(true) + }) + + it('adds ::jsonb casts and aliases property names to DB names in select', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id, email, createdAt') + + const [select] = supabase.callsFor('select') + expect(select.args[0]).toBe('id, email::jsonb, createdAt:created_at::jsonb') + }) + + it('encrypts equality operands as full-envelope jsonb text', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id, email').eq('email', 'a@b.com') + + const eqCalls = supabase.callsFor('eq') + expect(eqCalls).toHaveLength(1) + const [column, term] = eqCalls[0].args + expect(column).toBe('email') + // The operand must be the FULL storage envelope (v/i/c + index terms) so + // it satisfies the public.* domain CHECK when Postgres coerces it. + const parsed = JSON.parse(term as string) + expect(parsed.c).toBeDefined() + expect(parsed.i).toBeDefined() + expect(parsed.hm).toBeDefined() + }) + + it('passes non-encrypted filters through untouched', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id, email').eq('id', 42) + + const eqCalls = supabase.callsFor('eq') + expect(eqCalls[0].args).toEqual(['id', 42]) + }) + + it('maps property names to DB names in range filters', async () => { + const { es, supabase } = v3Instance() + + const from = new Date('2026-01-01T00:00:00.000Z') + await es.from('users', users).select('id, createdAt').gte('createdAt', from) + + const [gte] = supabase.callsFor('gte') + expect(gte.args[0]).toBe('created_at') + expect(JSON.parse(gte.args[1] as string).c).toBeDefined() + }) + + it('emits encrypted matches as PostgREST cs (bloom-filter containment)', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id, email').matches('email', 'a@b') + + const filterCalls = supabase.callsFor('filter') + expect(filterCalls).toHaveLength(1) + expect(filterCalls[0].args[0]).toBe('email') + expect(filterCalls[0].args[1]).toBe('cs') + // Full storage envelope: eql_v3.contains coerces the operand to the storage + // domain, whose CHECK requires `c`. + expect(JSON.parse(filterCalls[0].args[2] as string).c).toBeDefined() + // postgrest-js's native contains() would re-serialize the operand. + expect(supabase.callsFor('contains')).toHaveLength(0) + }) + + it('refuses contains() on an encrypted column, naming matches', async () => { + const { es } = v3Instance() + + expect(() => + es.from('users', users).select('id').contains('email', 'a@b'), + ).toThrow(/Use matches\(\)/) + }) + + // like/ilike on an ENCRYPTED column are an approximate compatibility shim that + // DELEGATES to matches: surrounding `%` are stripped and the residual term is + // fuzzy-matched, emitting the same `cs` wire as matches() (#617). + it('delegates like/ilike on an encrypted column to matches (cs)', async () => { + for (const op of ['like', 'ilike'] as const) { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id, email')[op]('email', '%a@b%') + + const filterCalls = supabase.callsFor('filter') + expect(filterCalls).toHaveLength(1) + expect(filterCalls[0].args[0]).toBe('email') + expect(filterCalls[0].args[1]).toBe('cs') + expect(JSON.parse(filterCalls[0].args[2] as string).c).toBeDefined() + // The stripped `%a@b%` needle reaches the SAME cs wire as matches('a@b'). + expect(JSON.parse(filterCalls[0].args[2] as string).pt).toBe('a@b') + } + }) + + // An internal `%` or any `_` cannot be approximated by trigram matching, so the + // shim throws rather than silently dropping the wildcard. + it('rejects a like/ilike pattern with an internal % or _ on an encrypted column', async () => { + const { es } = v3Instance() + + expect(() => + es.from('users', users).select('id').like('email', 'a%b'), + ).toThrow(/cannot honor/) + expect(() => + es.from('users', users).select('id').ilike('email', 'f_o'), + ).toThrow(/cannot honor/) + }) + + it('passes contains through to native cs on a plaintext column', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').contains('note', 'plain') + + expect(supabase.callsFor('contains')[0].args).toEqual(['note', 'plain']) + expect(supabase.callsFor('filter')).toHaveLength(0) + }) + + it('keeps like on plain columns as like', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id, email').like('note', '%x%') + + expect(supabase.callsFor('like')).toHaveLength(1) + expect(supabase.callsFor('filter')).toHaveLength(0) + }) + + // `assertNotEncryptedPattern` reads `this.v3Columns[column]` with no own-key + // guard. On a plain object that INHERITS `Object.prototype.constructor` — + // truthy — so a plaintext column named `constructor` would be misclassified + // as encrypted and `like` would throw. The `select('*')`/`order()` sites are + // covered by the `a plaintext column named \`constructor\`` block below; this + // pins the pattern-filter site. + it('treats a plaintext column named `constructor` as plaintext', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').like('constructor', '%x%') + + expect(supabase.callsFor('like')).toHaveLength(1) + expect(supabase.callsFor('like')[0].args[0]).toBe('constructor') + }) + + it('maps not(matches) on encrypted columns to not(cs)', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id, email') + .not('email', 'matches', 'a@b') + + const [not] = supabase.callsFor('not') + expect(not.args[0]).toBe('email') + expect(not.args[1]).toBe('cs') + }) + + // `not(col, 'contains', …)` on an encrypted column would negate a fuzzy bloom + // match under the `contains` name — the confusion #617 removes. It is rejected; + // use the honest `matches` spelling (above) or the raw `cs` operator. + it('rejects not(contains) on an encrypted column, steering to matches', () => { + const { es } = v3Instance() + expect(() => + es.from('users', users).select('id').not('email', 'contains', 'a@b'), + ).toThrow(/not apply to encrypted column .* Use not\(.*'matches'/) + }) + + // An encrypted in-list is emitted through `filter()` as a pre-formatted + // operand, NOT through postgrest-js's `in()`, which would leave the quotes + // inside each envelope unescaped. `supabase-v3-wire.test.ts` pins the bytes. + it('encrypts each element of an in() filter', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id, nickname') + .in('nickname', ['ada', 'grace']) + + expect(supabase.callsFor('in')).toHaveLength(0) + const [inCall] = supabase.callsFor('filter') + expect(inCall.args[0]).toBe('nickname') + expect(inCall.args[1]).toBe('in') + + const operand = inCall.args[2] as string + const values = operand + .slice(1, -1) + .split('","') + .map((e) => JSON.parse(e.replace(/^"|"$/g, '').replace(/\\(.)/g, '$1'))) + expect(values).toHaveLength(2) + expect(values[0].pt).toBe('ada') + expect(values[1].pt).toBe('grace') + }) + + it('maps match() keys to DB names and encrypts values', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id, nickname') + .match({ nickname: 'ada', id: 7 }) + + const [match] = supabase.callsFor('match') + const query = match.args[0] as Record + expect(JSON.parse(query.nickname as string).pt).toBe('ada') + expect(query.id).toBe(7) + }) + + it('rejects a query type the column does not support', async () => { + const { es } = v3Instance() + + // nickname is public.eql_v3_text_eq — equality only, no order/range + const { error, status } = await es + .from('users', users) + .select('id, nickname') + .gte('nickname', 'a') + + expect(status).toBe(500) + expect(error?.message).toContain('does not support orderAndRange') + }) + + it('rejects filters on storage-only columns', async () => { + const { es } = v3Instance() + + // active is public.eql_v3_boolean — storage only + const { error, status } = await es + .from('users', users) + .select('id') + // biome-ignore lint/suspicious/noExplicitAny: intentionally bypassing the type guard to prove the runtime guard + .eq('active' as any, true as any) + + expect(status).toBe(500) + expect(error?.message).toContain('does not support equality') + }) + + // Ordering ANY encrypted v3 column is rejected. The `*_ord` domains are + // `DOMAIN … AS jsonb` and the bundle declares no btree OPERATOR CLASS on them + // (it lints against one: `domain_opclass`), so `ORDER BY col` resolves through + // jsonb's default opclass — `jsonb_cmp` — and sorts by the envelope's byte + // structure, first key `bf`. Correct ordering needs `ORDER BY + // eql_v3.ord_term(col)`, which PostgREST's `order=` cannot express. + // + // The old guard only rejected columns LACKING orderAndRange, i.e. exactly the + // columns where the wrongness was obvious, and admitted the ORE-capable ones + // where it is silent. + it('orders an OPE-backed encrypted column by its op term', async () => { + const { es, supabase } = v3Instance() + + const { error } = await es + .from('users', users) + .select('id, createdAt') + .order('createdAt') + + expect(error).toBeNull() + // The jsonb path, not a bare column: `ORDER BY created_at` would sort the + // ciphertext envelope through jsonb's default opclass. + expect(supabase.callsFor('order')[0].args[0]).toBe('created_at->op') + }) + + it('rejects order() on an equality-only encrypted column', async () => { + const { es } = v3Instance() + + // `nickname` is public.eql_v3_text_eq: an `hm` term and nothing to sort by. + // (`amount` is IntegerOrd — OPE-backed, and therefore orderable.) + const { error, status } = await es + .from('users', users) + .select('id') + .order('nickname') + + expect(status).toBe(500) + expect(error?.message).toContain('cannot order by encrypted column') + expect(error?.message).toContain('no ordering term') + }) + + it('leaves plaintext columns untouched in order()', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id, note').order('note') + + const [order] = supabase.callsFor('order') + expect(order.args[0]).toBe('note') + }) + + it('rejects order() on a storage-only encrypted column', async () => { + const { es } = v3Instance() + + // active is public.eql_v3_boolean — storage only, so ordering it would sort ciphertext + const { error, status } = await es + .from('users', users) + .select('id') + .order('active') + + expect(status).toBe(500) + expect(error?.message).toContain('cannot order by encrypted column') + }) + + it('maps property names to DB names in the onConflict option', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .upsert({ email: 'a@b.com' }, { onConflict: 'createdAt' }) + + const [upsert] = supabase.callsFor('upsert') + expect((upsert.args[1] as { onConflict: string }).onConflict).toBe( + 'created_at', + ) + }) + + it('maps every column of a multi-column onConflict list', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .upsert({ email: 'a@b.com' }, { onConflict: 'createdAt,amount' }) + + const [upsert] = supabase.callsFor('upsert') + expect((upsert.args[1] as { onConflict: string }).onConflict).toBe( + 'created_at,amount', + ) + }) + + // `or()` had no v3 coverage at all. Any condition naming an encrypted column + // — under either its property or DB name — routes through the parse → rebuild + // path, where `toDbSpace` has already mapped names; the verbatim branch is + // reached only when every condition names a plaintext column, which needs no + // mapping. + it('maps property names to DB names in an or() string', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').or('createdAt.gte.2026-01-01') + + const [or] = supabase.callsFor('or') + expect(or.args[0] as string).toMatch(/^created_at\.gte\./) + }) + + it('passes an all-plaintext or() string through verbatim', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').or('note.eq.x,id.eq.1') + + const [or] = supabase.callsFor('or') + expect(or.args[0]).toBe('note.eq.x,id.eq.1') + }) + + it('rebuilds a mixed encrypted/plaintext or() string, mapping only the encrypted column', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or('createdAt.gte.2026-01-01,note.eq.x') + + // The encrypted operand is a JSON envelope containing commas, so the + // conditions cannot be split on ','. Assert on the boundaries instead. + const [or] = supabase.callsFor('or') + const emitted = or.args[0] as string + expect(emitted).toMatch(/^created_at\.gte\./) + expect(emitted.endsWith(',note.eq.x')).toBe(true) + }) + + // An all-plaintext or() string is forwarded verbatim, so its containment + // literal is never parsed. Naming an encrypted column forces the rebuild + // path — and there the literal's own commas must not be mistaken for + // condition separators, or `note` is filtered on the truncated `{vip`. + it('preserves a plaintext containment literal when rebuilding a mixed or() string', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or('email.eq.ada,note.cs.{vip,admin}') + + const emitted = supabase.callsFor('or')[0].args[0] as string + expect(emitted).toMatch(/^email\.eq\./) + expect(emitted.endsWith(',note.cs."{vip,admin}"')).toBe(true) + }) + + it('keeps every filter array correlated in a combined query', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id, email, createdAt') + .eq('email', 'a@b.com') + .not('nickname', 'eq', 'ada') + .or('createdAt.gte.2026-01-01,note.eq.x') + .match({ nickname: 'grace' }) + .order('note') + .limit(5) + + expect(supabase.callsFor('eq')[0].args[0]).toBe('email') + expect(supabase.callsFor('not')[0].args[0]).toBe('nickname') + expect(supabase.callsFor('or')[0].args[0] as string).toMatch( + /^created_at\./, + ) + expect( + (supabase.callsFor('match')[0].args[0] as Record) + .nickname, + ).toBeDefined() + // `order` can no longer carry an encrypted column, so the rename it used to + // exercise here is covered by the filter paths above. + expect(supabase.callsFor('order')[0].args[0]).toBe('note') + expect(supabase.callsFor('limit')[0].args[0]).toBe(5) + }) + + // Filter-capability errors are raised in `encryptFilterValues` (execute step + // 3); order-capability errors in `validateTransforms`, inside + // `buildAndExecuteQuery` (step 4). The filter must therefore win. Pins that + // precedence against a refactor that moves validation earlier. + it('reports the filter-capability error ahead of the order-capability error', async () => { + const { es } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id') + .gte('nickname', 'a') // text_eq: no orderAndRange + .order('active') // boolean: storage only + + expect(status).toBe(500) + expect(error?.message).toContain('does not support orderAndRange') + expect(error?.message).not.toContain('does not support ordering') + }) + + // `is` is a SQL predicate (PostgREST accepts only null/true/false), never a + // data operand — and a null operand is SQL NULL, not a value to search for. + // Only the regular `.is()` filter skipped encryption; every other collector + // encrypted whatever it was handed. See the v2 block for the released-side + // regressions. + describe('is / null operands are never encrypted', () => { + it('does not encrypt a regular is() operand', async () => { + const { es, supabase } = v3Instance() + await es.from('users', users).select('id').is('createdAt', null) + expect(supabase.callsFor('is')[0].args).toEqual(['created_at', null]) + }) + + // `IS NULL` is the only predicate a storage-only column supports, and the + // runtime has always forwarded it. The type surface now agrees (see + // supabase-v3.test-d.ts); this pins the runtime half. + it('forwards is(col, null) on a storage-only column', async () => { + const { es, supabase } = v3Instance() + await es.from('users', users).select('id').is('active', null) + expect(supabase.callsFor('is')[0].args).toEqual(['active', null]) + expect(supabase.callsFor('filter')).toHaveLength(0) + }) + + it('does not encrypt not(col, is, null)', async () => { + const { es, supabase } = v3Instance() + await es.from('users', users).select('id').not('createdAt', 'is', null) + expect(supabase.callsFor('not')[0].args).toEqual([ + 'created_at', + 'is', + null, + ]) + }) + + it('does not encrypt a raw filter() is operand', async () => { + const { es, supabase } = v3Instance() + await es.from('users', users).select('id').filter('createdAt', 'is', null) + expect(supabase.callsFor('filter')[0].args).toEqual([ + 'created_at', + 'is', + null, + ]) + }) + + it('does not encrypt a null match() value', async () => { + const { es, supabase } = v3Instance() + await es.from('users', users).select('id').match({ nickname: null }) + expect(supabase.callsFor('match')[0].args[0]).toEqual({ nickname: null }) + }) + + // The or-string verbatim branch keys on "was any VALUE encrypted". An `is` + // on an encrypted column encrypts nothing, so it would fall through to + // verbatim and forward the unmapped property name. It must rebuild whenever + // a condition REFERENCES an encrypted column. + it('maps the column name in an or() string whose only condition is an is', async () => { + const { es, supabase } = v3Instance() + await es.from('users', users).select('id').or('createdAt.is.null') + expect(supabase.callsFor('or')[0].args[0]).toBe('created_at.is.null') + }) + + it('maps names in a structured or() carrying an is', async () => { + const { es, supabase } = v3Instance() + await es + .from('users', users) + .select('id') + .or([{ column: 'createdAt', op: 'is', value: null }]) + expect(supabase.callsFor('or')[0].args[0]).toBe('created_at.is.null') + }) + + // `is` maps to the `equality` query type, so before the fix an `is` term + // reached the v3 capability gate and threw on a storage-only column. + it('does not raise a capability error for an is on a storage-only column', async () => { + const { es, supabase } = v3Instance() + const { status, error } = await es + .from('users', users) + .select('id') + .or('active.is.null') + + expect(error).toBeNull() + expect(status).toBe(200) + expect(supabase.callsFor('or')[0].args[0]).toBe('active.is.null') + }) + + it('encrypts the encrypted condition of a mixed or() but leaves the is alone', async () => { + const { es, supabase } = v3Instance() + await es + .from('users', users) + .select('id') + .or('nickname.eq.ada,createdAt.is.null') + + const emitted = supabase.callsFor('or')[0].args[0] as string + expect(emitted).toMatch(/^nickname\.eq\./) + expect(emitted.endsWith(',created_at.is.null')).toBe(true) + }) + }) + + it('reconstructs Date values from cast_as on decrypted rows', async () => { + const rows = [ + { + id: 1, + email: fakeEnvelope('a@b.com', 'email'), + createdAt: fakeEnvelope( + new Date('2026-01-02T03:04:05.000Z'), + 'created_at', + ), + }, + ] + const { es } = v3Instance(rows) + + const { data, error } = await es + .from('users', users) + .select('id, email, createdAt') + + expect(error).toBeNull() + expect(data).toHaveLength(1) + expect(data![0].email).toBe('a@b.com') + expect(data![0].createdAt).toBeInstanceOf(Date) + expect((data![0].createdAt as Date).toISOString()).toBe( + '2026-01-02T03:04:05.000Z', + ) + }) + + // `.or()` string conditions carry raw PostgREST operators, so free-text search + // arrives as `cs`. The three or() string tests above use `gte`/`eq`/`is`, so + // the freeTextSearch capability branch never ran. + describe('or() with encrypted pattern and structured conditions', () => { + it('encrypts an encrypted cs inside an or() string and keeps the operator', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').or('email.cs.ada') + + const emitted = supabase.callsFor('or')[0].args[0] as string + // The envelope is JSON (commas, braces), so `formatOrValue` quotes it. + expect(emitted).toMatch(/^email\.cs\."/) + expect(JSON.parse(orOperand(emitted, 'email.cs.')).c).toBeDefined() + }) + + it('gates an or() cs condition on the freeTextSearch capability', async () => { + const { es } = v3Instance() + + // amount is public.eql_v3_integer_ord — no match index. Before the query-type + // seam this was encrypted as an equality term and silently accepted. + const { error, status } = await es + .from('users', users) + .select('id') + .or('amount.cs.5') + + expect(status).toBe(500) + expect(error?.message).toContain('does not support freeTextSearch') + }) + + it('rejects an encrypted like inside an or() string', async () => { + const { es } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id') + .or('email.like.ada') + + expect(status).toBe(500) + expect(error?.message).toContain('unsupported raw filter operator "like"') + }) + + // PostgREST spells negation `column.not..`. The parser split on + // the first two dots, so this parsed as `{ op: 'not', value: 'in.(ada,grace)' }` + // — the `in`-split never fired and the literal string `in.(ada,grace)` was + // encrypted as ONE plaintext. Silent: the filter matched nothing. + it('encrypts each element of a NEGATED in-list inside or()', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or('nickname.not.in.(ada,grace)') + + const emitted = supabase.callsFor('or')[0].args[0] as string + expect(emitted).toMatch(/^nickname\.not\.in\.\(/) + // Never the literal operand, and never one ciphertext for the whole list. + expect(emitted).not.toContain('in.(ada,grace)') + expect(emitted).not.toContain('"pt":["ada","grace"]') + + const operands = emitted + .slice('nickname.not.in.('.length, -1) + .split('","') + expect(operands).toHaveLength(2) + const pts = operands.map( + (o) => JSON.parse(o.replace(/^"|"$/g, '').replace(/\\(.)/g, '$1')).pt, + ) + expect(pts).toEqual(['ada', 'grace']) + }) + + it('preserves negation on a scalar encrypted or() condition', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').or('nickname.not.eq.ada') + + const emitted = supabase.callsFor('or')[0].args[0] as string + expect(emitted).toMatch(/^nickname\.not\.eq\."/) + expect(JSON.parse(orOperand(emitted, 'nickname.not.eq.')).pt).toBe('ada') + }) + + it('leaves a negated plaintext or() condition verbatim', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').or('note.not.in.(a,b)') + + expect(supabase.callsFor('or')[0].args[0]).toBe('note.not.in.(a,b)') + }) + + // The structured form's encrypted path (`query-builder.ts:1065`). The + // existing structured test uses `is`, which after `fd33aadf` encrypts + // nothing and so never populates `orStructuredConditionMap`. + it('encrypts the operand of a structured or() condition', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or([ + { + column: 'createdAt', + op: 'gte', + value: new Date('2026-01-01T00:00:00.000Z'), + }, + ]) + + const emitted = supabase.callsFor('or')[0].args[0] as string + expect(emitted).toMatch(/^created_at\.gte\."/) + expect(JSON.parse(orOperand(emitted, 'created_at.gte.')).c).toBeDefined() + }) + + // The regular filter path splits an `in` array and encrypts each element + // (query-builder.ts:533). The or() path had no such case: it pushed ONE + // term whose value was the whole array, so the `(a,b)` list form was lost + // and the filter could never match. Fails closed, silently. + it('encrypts each element of an in() list inside an or() string', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').or('nickname.in.(ada,grace)') + + const emitted = supabase.callsFor('or')[0].args[0] as string + expect(emitted).toMatch(/^nickname\.in\.\(/) + + // Two distinct encrypted operands, not one ciphertext of the array. + const plain = emitted.replace(/\\(.)/g, '$1') + expect(plain).toContain('"pt":"ada"') + expect(plain).toContain('"pt":"grace"') + expect(plain).not.toContain('"pt":["ada","grace"]') + }) + + it('encrypts each element of an in() list in a structured or()', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or([{ column: 'nickname', op: 'in', value: ['ada', 'grace'] }]) + + const emitted = supabase.callsFor('or')[0].args[0] as string + expect(emitted).toMatch(/^nickname\.in\.\(/) + const plain = emitted.replace(/\\(.)/g, '$1') + expect(plain).toContain('"pt":"ada"') + expect(plain).toContain('"pt":"grace"') + expect(plain).not.toContain('"pt":["ada","grace"]') + }) + + it('rewrites an encrypted matches in a structured or() to cs', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or([{ column: 'email', op: 'matches', value: 'ada' }]) + + expect(supabase.callsFor('or')[0].args[0] as string).toMatch( + /^email\.cs\."/, + ) + }) + + // The operator token depends on the OPERATOR, never on whether the operand + // was encrypted. `note` is a plaintext passthrough, so nothing encrypts and + // the rewrite used to be skipped, emitting `note.contains.plain` — which + // PostgREST rejects (PGRST100). Plaintext `contains` is advertised as native + // jsonb/array containment, so this is the path that must work. + it('rewrites a plaintext contains in a structured or() to cs', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or([{ column: 'note', op: 'contains', value: 'plain' }]) + + expect(supabase.callsFor('or')[0].args[0]).toBe('note.cs.plain') + }) + + it('emits an array operand as a containment literal, not an in-list', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or([{ column: 'note', op: 'contains', value: ['vip', 'admin'] }]) + + expect(supabase.callsFor('or')[0].args[0]).toBe('note.cs."{vip,admin}"') + }) + + it('rewrites contains alongside an encrypted condition in one or()', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or([ + { column: 'email', op: 'eq', value: 'ada@example.com' }, + { column: 'note', op: 'contains', value: 'plain' }, + ]) + + expect(supabase.callsFor('or')[0].args[0] as string).toMatch( + /,note\.cs\.plain$/, + ) + }) + }) + + describe('update / delete / single / maybeSingle', () => { + it('updates with raw envelopes keyed by DB column name', async () => { + const { es, supabase } = v3Instance() + + const createdAt = new Date('2026-01-02T03:04:05.000Z') + await es + .from('users', users) + .update({ email: 'a@b.com', createdAt }) + .eq('id', 1) + + const [update] = supabase.callsFor('update') + const body = update.args[0] as Record + expect(Object.keys(body).sort()).toEqual(['created_at', 'email']) + expect(isFakeEnvelope(body.email)).toBe(true) + expect((body.email as Record).data).toBeUndefined() + expect(isFakeEnvelope(body.created_at)).toBe(true) + }) + + // `delete()` carries no body at all — `buildAndExecuteQuery` calls + // `query.delete(options)`. The WHERE operand still has to be encrypted. + it('sends no body on delete but still encrypts the WHERE operand', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).delete().eq('nickname', 'ada') + + const [del] = supabase.callsFor('delete') + expect(del).toBeDefined() + expect(del.args[0]).toBeUndefined() + + const [eq] = supabase.callsFor('eq') + expect(eq.args[0]).toBe('nickname') + expect(JSON.parse(eq.args[1] as string).pt).toBe('ada') + }) + + it('single() returns one decrypted object, not an array', async () => { + const row = { + id: 1, + email: fakeEnvelope('a@b.com', 'email'), + createdAt: fakeEnvelope( + new Date('2026-01-02T03:04:05.000Z'), + 'created_at', + ), + } + const { es, supabase } = v3Instance(row) + + const { data, error } = await es + .from('users', users) + .select('id, email, createdAt') + .single() + + expect(error).toBeNull() + expect(supabase.callsFor('single')).toHaveLength(1) + expect(Array.isArray(data)).toBe(false) + // `data` is declared `T[] | null` on the shared builder surface; single() + // narrows it to one row at runtime only. + const single = data as unknown as { email: string; createdAt: Date } + expect(single.email).toBe('a@b.com') + expect(single.createdAt).toBeInstanceOf(Date) + }) + + it('maybeSingle() returns null for null result data without throwing', async () => { + const { es } = v3Instance(null) + + const { data, error } = await es + .from('users', users) + .select('id, email') + .maybeSingle() + + expect(error).toBeNull() + expect(data).toBeNull() + }) + }) + + // `postprocessDecryptedRow` reconstructs `Date` from `cast_as`. Only the + // string-via-property-key arm was covered. + describe('postprocessDecryptedRow branches', () => { + it('leaves a null date-like value as null', async () => { + const { es } = v3Instance([{ id: 1, createdAt: null }]) + + const { data } = await es.from('users', users).select('id, createdAt') + + expect(data![0].createdAt).toBeNull() + }) + + it('leaves an already-Date value untouched', async () => { + const existing = new Date('2026-01-02T03:04:05.000Z') + const { es } = v3Instance([{ id: 1, createdAt: existing }]) + + const { data } = await es.from('users', users).select('id, createdAt') + + expect(data![0].createdAt).toBe(existing) + }) + + it('reconstructs a Date from a numeric epoch', async () => { + const epoch = Date.parse('2026-01-02T03:04:05.000Z') + const { es } = v3Instance([{ id: 1, createdAt: epoch }]) + + const { data } = await es.from('users', users).select('id, createdAt') + + expect(data![0].createdAt).toBeInstanceOf(Date) + expect((data![0].createdAt as Date).toISOString()).toBe( + '2026-01-02T03:04:05.000Z', + ) + }) + + // Selecting by raw DB name means the row comes back keyed `created_at`, + // the only way to reach the `dbName` half of the two-key branch. It also + // exercises the `value == null` skip on the absent `createdAt` key. + it('reconstructs a Date on a row keyed by the raw DB column name', async () => { + const rows = [ + { + id: 1, + created_at: fakeEnvelope( + new Date('2026-01-02T03:04:05.000Z'), + 'created_at', + ), + }, + ] + const { es } = v3Instance(rows) + + const { data } = await es.from('users', users).select('id, created_at') + + const row = data![0] as unknown as Record + expect(row.created_at).toBeInstanceOf(Date) + expect((row.created_at as Date).toISOString()).toBe( + '2026-01-02T03:04:05.000Z', + ) + }) + + // A caller-chosen PostgREST alias keys the row by neither the property nor + // the DB name, so the reconstruction has to follow the select string. This + // regressed once when the alias→DB map was dropped from `buildSelectString`. + it('reconstructs a Date on a row keyed by a caller-chosen alias', async () => { + const rows = [ + { id: 1, ts: fakeEnvelope(new Date('2026-01-02T03:04:05.000Z'), 'ts') }, + ] + const { es, supabase } = v3Instance(rows) + + const { data } = await es.from('users', users).select('id, ts:createdAt') + + // The alias survives into the emitted select, so PostgREST keys rows `ts`. + expect(supabase.callsFor('select')[0].args[0]).toBe( + 'id, ts:created_at::jsonb', + ) + const row = data![0] as unknown as Record + expect(row.ts).toBeInstanceOf(Date) + expect((row.ts as Date).toISOString()).toBe('2026-01-02T03:04:05.000Z') + }) + + // An alias onto the raw DB name takes the other `resolveSelectToken` branch. + it('reconstructs a Date on an alias of the raw DB column name', async () => { + const rows = [ + { at: fakeEnvelope(new Date('2026-01-02T03:04:05.000Z'), 'at') }, + ] + const { es } = v3Instance(rows) + + const { data } = await es.from('users', users).select('at:created_at') + + const row = data![0] as unknown as Record + expect(row.at).toBeInstanceOf(Date) + expect((row.at as Date).toISOString()).toBe('2026-01-02T03:04:05.000Z') + }) + }) + + // `notFilterOperator` was asserted only on the operator, never on the + // operand — a regression dropping envelope encoding on the not() path would + // have passed. + describe('notFilterOperator', () => { + it('sends a full envelope as the not(cs) operand', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').not('email', 'matches', 'a@b') + + const [not] = supabase.callsFor('not') + expect(not.args[0]).toBe('email') + expect(not.args[1]).toBe('cs') + expect(JSON.parse(not.args[2] as string).c).toBeDefined() + }) + + it('leaves not(like) on an encrypted column as like — no silent cs rewrite', async () => { + const { es, supabase } = v3Instance() + + // `not()` takes a raw operator string, so it bypasses the like() guard. + // It must NOT be rewritten to cs: `~~` does not exist on the domain, so + // PostgREST errors loudly instead of returning a wrong row set. + await es.from('users', users).select('id').not('email', 'like', 'a@b') + + expect(supabase.callsFor('not')[0].args[1]).toBe('like') + }) + + it('leaves not(like) on a plaintext column as like with a plain operand', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').not('note', 'like', '%x%') + + expect(supabase.callsFor('not')[0].args).toEqual(['note', 'like', '%x%']) + }) + + it('keeps a non-pattern operator on an encrypted column, still enveloped', async () => { + const { es, supabase } = v3Instance() + + await es.from('users', users).select('id').not('nickname', 'eq', 'ada') + + const [not] = supabase.callsFor('not') + expect(not.args[0]).toBe('nickname') + expect(not.args[1]).toBe('eq') + expect(JSON.parse(not.args[2] as string).pt).toBe('ada') + }) + }) + + // `v3Columns` / `dbToProp` are null-prototype and `dbNameFor` uses + // `Object.hasOwn` precisely so a plaintext DB column named `constructor` + // cannot resolve to the inherited `Object.prototype.constructor`. Nothing + // exercised those guards through the builder. + describe('a plaintext column named `constructor`', () => { + // Only encrypted columns are declared; `constructor` is a plaintext DB + // column, as introspection would report it. + const protoTable = encryptedTable('proto', { + email: types.TextSearch('email'), + createdAt: types.TimestampOrd('created_at'), + }) + const PROTO_ALL_COLUMNS = ['id', 'email', 'created_at', 'constructor'] + + function protoInstance() { + const supabase = createMockSupabase() + const q = new EncryptedQueryBuilderV3Impl( + 'proto', + protoTable, + createMockEncryptionClient(), + supabase.client, + PROTO_ALL_COLUMNS, + // biome-ignore lint/suspicious/noExplicitAny: addressing a column outside the declared row type + ) as any + return { q, supabase } + } + + it('expands it as a real column in select(*)', async () => { + const { q, supabase } = protoInstance() + + await q.select('*') + + const emitted = supabase.callsFor('select')[0].args[0] as string + expect(emitted.split(', ')).toEqual([ + 'id', + 'email::jsonb', + 'createdAt:created_at::jsonb', + 'constructor', + ]) + }) + + it('resolves it as a plaintext filter column', async () => { + const { q, supabase } = protoInstance() + + await q.select('id').eq('constructor', 'x') + + expect(supabase.callsFor('eq')[0].args).toEqual(['constructor', 'x']) + }) + + // The sharpest of the three: `validateTransforms` indexes `v3Columns` + // without an own-key guard, so an inherited `constructor` would resolve to + // a Function and blow up on `.getQueryCapabilities()`. + it('orders by it without consulting the capability guard', async () => { + const { q, supabase } = protoInstance() + + const { error } = await q.select('id').order('constructor') + + expect(error).toBeNull() + expect(supabase.callsFor('order')[0].args[0]).toBe('constructor') + }) + }) +}) + +// --------------------------------------------------------------------------- +// v2 regression — the dialect seams must leave the v2 wire encoding untouched +// --------------------------------------------------------------------------- + +describe('encryptedSupabase (v2) wire encoding is unchanged by the dialect seams', () => { + function v2Instance(resultData: unknown = []) { + const supabase = createMockSupabase(resultData) + const es = encryptedSupabase({ + encryptionClient: createMockEncryptionClient(), + supabaseClient: supabase.client, + }) + return { es, supabase } + } + + it('wraps encrypted mutation values in the { data } composite shape', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).insert({ email: 'a@b.com', note: 'x' }) + + const [insert] = supabase.callsFor('insert') + const body = insert.args[0] as Record + expect(body.email).toHaveProperty('data') + expect(isFakeEnvelope((body.email as Record).data)).toBe( + true, + ) + expect(body.note).toBe('x') + }) + + it('encodes filter terms as composite literals via encryptQuery', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id, email').eq('email', 'a@b.com') + + const [eq] = supabase.callsFor('eq') + expect(eq.args).toEqual(['email', '("a@b.com")']) + }) + + it('keeps like on encrypted columns as like', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id, email').like('email', 'a@b') + + expect(supabase.callsFor('like')).toHaveLength(1) + expect(supabase.callsFor('filter')).toHaveLength(0) + }) + + it('adds plain ::jsonb casts without aliasing', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id, email, age') + + const [select] = supabase.callsFor('select') + expect(select.args[0]).toBe('id, email::jsonb, age::jsonb') + }) + + it('passes order() column names through unchanged', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id, age').order('age') + + const [order] = supabase.callsFor('order') + expect(order.args[0]).toBe('age') + }) + + it('passes the onConflict option through by reference', async () => { + const { es, supabase } = v2Instance() + + const options = { onConflict: 'email' } + await es.from('users', usersV2).upsert({ email: 'a@b.com' }, options) + + const [upsert] = supabase.callsFor('upsert') + expect(upsert.args[1]).toBe(options) + }) + + it('passes an all-plaintext or() string through verbatim', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id').or('id.eq.1,note.eq.x') + + const [or] = supabase.callsFor('or') + expect(or.args[0]).toBe('id.eq.1,note.eq.x') + }) + + // `contains` is not a PostgREST operator in EITHER dialect — the structured + // or() path emitted `note.contains.x` on v2 too, since the base builder never + // translated the token. Fixed in `rebuildOrString`, so both dialects inherit it. + it('translates a structured or() contains to cs', async () => { + const { es, supabase } = v2Instance() + + await es + .from('users', usersV2) + .select('id') + .or([{ column: 'note', op: 'contains', value: 'x' }]) + + expect(supabase.callsFor('or')[0].args[0]).toBe('note.cs.x') + }) + + // ------------------------------------------------------------------------- + // Characterization tests for the paths `toDbSpace()` will rewrite. Each pins + // the correlation between the term collector (`encryptFilterValues`) and the + // applier (`applyFilters`), which agree only by array index / column name. + // ------------------------------------------------------------------------- + + it('match() encrypts encrypted keys and passes plaintext through', async () => { + const { es, supabase } = v2Instance() + + await es + .from('users', usersV2) + .select('id') + .match({ email: 'a@b.com', note: 'plain' }) + + const [match] = supabase.callsFor('match') + const query = match.args[0] as Record + expect(query.email).toBe('("a@b.com")') + expect(query.note).toBe('plain') + // Key order survives the Record -> entries -> Record round-trip + expect(Object.keys(query)).toEqual(['email', 'note']) + }) + + it('not() encrypts on encrypted columns and passes plaintext through', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id').not('email', 'eq', 'a@b.com') + await es.from('users', usersV2).select('id').not('note', 'eq', 'plain') + + const [encrypted, plain] = supabase.callsFor('not') + expect(encrypted.args).toEqual(['email', 'eq', '("a@b.com")']) + expect(plain.args).toEqual(['note', 'eq', 'plain']) + }) + + // The v2 composite literal `("a@b.com")` is itself quote-bearing, so it needs + // the same escaped operand as v3 — postgrest-js's `in()` would emit + // `in.("("a@b.com")")` and PostgREST would reject it. + it('in() encrypts each element and leaves plaintext arrays alone', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id').in('email', ['a@b.com', 'c@d']) + await es.from('users', usersV2).select('id').in('note', ['x', 'y']) + + const [encrypted] = supabase.callsFor('filter') + expect(encrypted.args).toEqual([ + 'email', + 'in', + '("(\\"a@b.com\\")","(\\"c@d\\")")', + ]) + + const [plain] = supabase.callsFor('in') + expect(plain.args[1]).toEqual(['x', 'y']) + }) + + it('is() leaves the value untouched on an encrypted column', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id').is('email', null) + + const [is] = supabase.callsFor('is') + expect(is.args).toEqual(['email', null]) + }) + + it('filter() encrypts the operand on an encrypted column', async () => { + const { es, supabase } = v2Instance() + + await es + .from('users', usersV2) + .select('id') + .filter('email', 'eq', 'a@b.com') + await es.from('users', usersV2).select('id').filter('note', 'eq', 'plain') + + const [encrypted, plain] = supabase.callsFor('filter') + expect(encrypted.args).toEqual(['email', 'eq', '("a@b.com")']) + expect(plain.args).toEqual(['note', 'eq', 'plain']) + }) + + // The single most important characterization test: a strict nonempty SUBSET + // of the or-string's conditions is encrypted, so the condition index `j` must + // agree between the two `parseOrString` calls that `toDbSpace()` collapses + // into one. + it('or() rebuilds a mixed encrypted/plaintext string, keeping each condition on its own column', async () => { + const { es, supabase } = v2Instance() + + await es + .from('users', usersV2) + .select('id') + .or('email.eq.a@b.com,note.eq.x') + + const [or] = supabase.callsFor('or') + const emitted = or.args[0] as string + const [emailCond, noteCond] = emitted.split(',') + expect(emailCond).toContain('email.eq.') + expect(emailCond).toContain('a@b.com') + expect(noteCond).toBe('note.eq.x') + }) + + it('keeps every filter array correlated in a combined query', async () => { + const { es, supabase } = v2Instance() + + await es + .from('users', usersV2) + .select('id, email, age') + .eq('email', 'a@b.com') + .not('age', 'eq', 30) + .or('email.eq.c@d,note.eq.x') + .match({ email: 'e@f.com' }) + .filter('age', 'gte', 18) + .order('age') + .limit(10) + + expect(supabase.callsFor('eq')[0].args).toEqual(['email', '("a@b.com")']) + expect(supabase.callsFor('not')[0].args).toEqual(['age', 'eq', '("30")']) + expect(supabase.callsFor('or')[0].args[0]).toContain('note.eq.x') + expect( + (supabase.callsFor('match')[0].args[0] as Record).email, + ).toBe('("e@f.com")') + expect(supabase.callsFor('filter')[0].args).toEqual([ + 'age', + 'gte', + '("18")', + ]) + expect(supabase.callsFor('order')[0].args[0]).toBe('age') + expect(supabase.callsFor('limit')[0].args[0]).toBe(10) + }) + + // Released-side regressions. `is` is a SQL predicate — PostgREST accepts only + // null/true/false — and a null operand is SQL NULL, never a value to search + // for. Only the regular `.is()` filter skipped encryption; every other + // collector encrypted whatever it was handed, emitting operands PostgREST + // rejects. + describe('is / null operands are never encrypted', () => { + it('does not encrypt not(col, is, null)', async () => { + const { es, supabase } = v2Instance() + await es.from('users', usersV2).select('id').not('age', 'is', null) + expect(supabase.callsFor('not')[0].args).toEqual(['age', 'is', null]) + }) + + it('does not encrypt a raw filter() is operand', async () => { + const { es, supabase } = v2Instance() + await es.from('users', usersV2).select('id').filter('age', 'is', null) + expect(supabase.callsFor('filter')[0].args).toEqual(['age', 'is', null]) + }) + + it('forwards an or() is condition unencrypted', async () => { + const { es, supabase } = v2Instance() + await es.from('users', usersV2).select('id').or('age.is.null') + expect(supabase.callsFor('or')[0].args[0]).toBe('age.is.null') + }) + + it('does not encrypt a null eq() operand', async () => { + const { es, supabase } = v2Instance() + await es.from('users', usersV2).select('id').eq('email', null) + expect(supabase.callsFor('eq')[0].args).toEqual(['email', null]) + }) + + it('does not encrypt a null match() value', async () => { + const { es, supabase } = v2Instance() + await es.from('users', usersV2).select('id').match({ email: null }) + expect(supabase.callsFor('match')[0].args[0]).toEqual({ email: null }) + }) + + it('does not encrypt null elements of an in() list', async () => { + const { es, supabase } = v2Instance() + await es + .from('users', usersV2) + .select('id') + .in('email', ['a@b.com', null]) + // `null` stays a bare PostgREST `null`, never a ciphertext. + expect(supabase.callsFor('filter')[0].args).toEqual([ + 'email', + 'in', + '("(\\"a@b.com\\")",null)', + ]) + }) + + it('treats is() as a predicate even with a non-null operand', async () => { + const { es, supabase } = v2Instance() + await es.from('users', usersV2).select('id').is('email', false) + expect(supabase.callsFor('is')[0].args).toEqual(['email', false]) + }) + }) +}) + +// --------------------------------------------------------------------------- +// Property → DB name collision +// +// `createdAt` is declared as the property for DB column `created_at`. If the +// database ALSO has a distinct plaintext column literally named `createdAt`, +// `expandAllColumns` maps `created_at → createdAt` and passes the plaintext +// `createdAt` through unchanged, so `select('*')` emits the same aliased token +// twice and PostgREST returns the encrypted column under `createdAt`. The real +// plaintext column is never selected. Nothing downstream can disambiguate, so +// the builder must refuse to construct. +// --------------------------------------------------------------------------- + +describe('v3 property/DB name collision', () => { + const collidingColumns = [ + 'id', + 'email', + 'nickname', + 'amount', + 'created_at', + 'createdAt', // distinct plaintext column colliding with the property name + 'active', + 'note', + ] + + it('throws when a property name collides with a different DB column', () => { + const supabase = createMockSupabase() + expect( + () => + new EncryptedQueryBuilderV3Impl( + 'users', + users, + createMockEncryptionClient(), + supabase.client, + collidingColumns, + ), + ).toThrow(/createdAt.*created_at|collide/) + }) + + it('constructs normally when no property name collides', () => { + const supabase = createMockSupabase() + expect( + () => + new EncryptedQueryBuilderV3Impl( + 'users', + users, + createMockEncryptionClient(), + supabase.client, + USERS_ALL_COLUMNS, + ), + ).not.toThrow() + }) +}) + +// --------------------------------------------------------------------------- +// encryptCollectedTerms: failure arm + lockContext/audit threading +// +// The existing 500-status tests all reach 500 via the CAPABILITY GUARD, which +// throws before `encryptionClient.encrypt()` is ever called — so they pass even +// if the failure/threading block below is deleted wholesale. These do not: they +// need a client whose encrypt() actually fails, and one that records what was +// threaded onto the operation. +// --------------------------------------------------------------------------- + +/** An encrypt operation that resolves to a failure result. */ +function failingEncryptionClient(message: string) { + const op = { + withLockContext: () => op, + audit: () => op, + then: ( + onfulfilled?: ((v: unknown) => unknown) | null, + onrejected?: ((r: unknown) => unknown) | null, + ) => + Promise.resolve({ failure: { message } }).then(onfulfilled, onrejected), + } + return { encrypt: () => op } +} + +/** An encrypt operation that records `withLockContext` / `audit` calls. */ +function recordingEncryptionClient() { + const withLockContext = vi.fn() + const audit = vi.fn() + const op: Record = { + withLockContext: (...a: unknown[]) => { + withLockContext(...a) + return op + }, + audit: (...a: unknown[]) => { + audit(...a) + return op + }, + then: ( + onfulfilled?: ((v: unknown) => unknown) | null, + onrejected?: ((r: unknown) => unknown) | null, + ) => + Promise.resolve({ data: fakeEnvelope('a@b.com', 'email') }).then( + onfulfilled, + onrejected, + ), + } + return { client: { encrypt: () => op }, withLockContext, audit } +} + +function builderWith(encryptionClient: unknown) { + const supabase = createMockSupabase() + return new EncryptedQueryBuilderV3Impl( + 'users', + users, + encryptionClient as never, + supabase.client, + USERS_ALL_COLUMNS, + ) +} + +describe('v3 encryptCollectedTerms', () => { + it('surfaces a filter-term encryption failure as a 500 response', async () => { + const builder = builderWith(failingEncryptionClient('boom')) + + const { error, status } = await builder + .select('id, email') + .eq('email', 'a@b.com') + + expect(status).toBe(500) + expect(error?.message).toContain('Failed to encrypt query terms') + expect(error?.message).toContain('boom') + }) + + it('threads lockContext and audit onto the filter-term encryption', async () => { + const { client, withLockContext, audit } = recordingEncryptionClient() + const lockContext = { identify: () => {} } as never + const auditConfig = { metadata: { a: 1 } } + + await builderWith(client) + .withLockContext(lockContext) + .audit(auditConfig) + .select('id, email') + .eq('email', 'a@b.com') + + // Dropping either call would encrypt query terms under the wrong key, or + // silently lose the audit trail, with no test failing today. + expect(withLockContext).toHaveBeenCalledWith(lockContext) + expect(audit).toHaveBeenCalledWith(auditConfig) + }) +}) + +// --------------------------------------------------------------------------- +// Date reconstruction on the single-row decrypt path +// +// The `postprocessDecryptedRow` branches themselves are covered above; what is +// not, is that the SINGLE-row call site invokes it at all. Only the array path +// was exercised, so a missed reconstruction here hands the caller a string +// where the row type promises a Date. +// --------------------------------------------------------------------------- + +describe('v3 single() decrypt path', () => { + // `postprocessDecryptedRow` is called from both the array path and the + // single-row path; only the array path was covered. A missed reconstruction + // here hands the caller a string where the row type promises a Date. + it('reconstructs Date on the single() path', async () => { + const iso = '2026-01-02T03:04:05.000Z' + const { es } = v3Instance({ + id: 1, + createdAt: fakeEnvelope(new Date(iso), 'created_at'), + }) + + const { data, error } = await es + .from('users', users) + .select('id, createdAt') + .single() + + expect(error).toBeNull() + const row = data as unknown as { createdAt: Date } + expect(row.createdAt).toBeInstanceOf(Date) + expect(row.createdAt.toISOString()).toBe(iso) + }) +}) + +// --------------------------------------------------------------------------- +// Raw .filter() query-type resolution (Workstream D) +// +// Every other term collector derives `queryType` from the operator; the raw +// filter loop hardcoded `'equality'`. In v3 the query type is ONLY a capability +// gate (the operand is always the full storage envelope), so a wrong query type +// is a wrong accept/reject — it does not corrupt the ciphertext. The victim is +// `bio` (public.eql_v3_text_match, MATCH_ONLY): equality:false, freeTextSearch:true. +// --------------------------------------------------------------------------- + +describe('v3 raw filter() resolves the query type from the operator', () => { + it('accepts cs on a match-only column and emits it verbatim', async () => { + const { es, supabase } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id') + .filter('bio', 'cs', 'ada') + + expect(error).toBeNull() + expect(status).toBe(200) + const [call] = supabase.callsFor('filter') + expect(call.args[0]).toBe('bio') + expect(call.args[1]).toBe('cs') + expect(JSON.parse(call.args[2] as string).pt).toBe('ada') + }) + + it('accepts gte on an ord column as an orderAndRange query', async () => { + const { es } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id') + .filter('amount', 'gte', 10) + + expect(error).toBeNull() + expect(status).toBe(200) + }) + + // The raw path reached `in` with no element-split, so the whole list was + // encrypted as one equality term and the filter matched nothing. It now + // mirrors the `not(…, 'in', …)` contract exactly. + it('encrypts a raw in-list element-wise, not as one whole-list term', async () => { + const { es, supabase } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id') + .filter('nickname', 'in', ['ada', 'grace']) + + expect(error).toBeNull() + expect(status).toBe(200) + + const [call] = supabase.callsFor('filter') + expect(call.args[0]).toBe('nickname') + expect(call.args[1]).toBe('in') + + // One envelope per element, quoted into a PostgREST list literal — never a + // single ciphertext of the literal string `("ada","grace")`. + const operand = call.args[2] as string + expect(operand.startsWith('(')).toBe(true) + expect(operand.endsWith(')')).toBe(true) + const plaintexts = [...operand.matchAll(/\\"pt\\":\\"([^\\]+)\\"/g)].map( + (m) => m[1], + ) + expect(plaintexts).toEqual(['ada', 'grace']) + }) + + it('rejects a raw in-list passed as a PostgREST list literal', async () => { + const { es } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id') + .filter('nickname', 'in', '("ada","grace")') + + expect(status).toBe(500) + expect(error?.message).toMatch(/requires an array of values/) + }) + + it('leaves a raw in-list on a plaintext column untouched', async () => { + const { es, supabase } = v3Instance() + + const { error } = await es + .from('users', users) + .select('id') + .filter('id', 'in', [1, 2]) + + expect(error).toBeNull() + const [call] = supabase.callsFor('filter') + expect(call.args[2]).toEqual([1, 2]) + }) + + it('rejects cs on an ord column, which has no freeTextSearch capability', async () => { + const { es } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id') + .filter('amount', 'cs', 'ada') + + expect(status).toBe(500) + expect(error?.message).toContain('does not support freeTextSearch') + }) + + it('rejects an unsupported raw operator rather than defaulting to equality', async () => { + const { es } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id') + .filter('email', 'ov', 'ada') + + expect(status).toBe(500) + expect(error?.message).toContain('unsupported raw filter operator "ov"') + }) + + it('leaves a raw filter on a plaintext column untouched', async () => { + const { es, supabase } = v3Instance() + + const { error } = await es + .from('users', users) + .select('id') + .filter('note', 'ov', 'anything') + + expect(error).toBeNull() + expect(supabase.callsFor('filter')[0].args).toEqual([ + 'note', + 'ov', + 'anything', + ]) + }) + + // `encryptCollectedTerms` rejects any queryType outside the three scalar EQL + // v3 kinds. No public call path can produce a fourth — `mapFilterOpToQueryType`, + // `queryTypeForRawOp` and `queryTypeForOrOp` are exhaustive — so this backstop + // is unreachable without breaking the internal contract, which is exactly what + // the subclass below does. Keep the guard: it is what a future producer + // gaining a fourth QueryTypeName would trip over. + it('rejects a query type outside the scalar EQL v3 kinds', async () => { + const supabase = createMockSupabase() + + class BogusQueryType extends EncryptedQueryBuilderV3Impl { + protected override queryTypeForRawOp(_operator: string) { + return 'searchableJson' as never + } + } + + const builder = new BogusQueryType( + 'users', + users, + createMockEncryptionClient(), + supabase.client, + USERS_ALL_COLUMNS, + ) + + const { error, status } = await builder + .select('id') + .filter('email', 'eq', 'a@b.com') + + expect(status).toBe(500) + expect(error?.message).toContain('query type "searchableJson"') + expect(error?.message).toContain('not supported on scalar EQL v3 columns') + }) +}) + +// --------------------------------------------------------------------------- +// In-list encryption batching +// +// The element-wise `in`/`not.in` fix (each element its own term, so the list is +// never encrypted whole) fed N same-column terms into `encryptCollectedTerms`, +// which spent one ZeroKMS/FFI round-trip on each. `bulkEncrypt` takes ONE +// `{table, column}` for a whole list, so terms must be grouped by column before +// the crossing — a single bulk call over a multi-column term array would stamp +// one column onto every plaintext. +// --------------------------------------------------------------------------- + +describe('v3 in-list term encryption batches by column', () => { + function batchingInstance() { + const supabase = createMockSupabase() + const encryption = createMockEncryptionClient() + const bulkEncrypt = vi.spyOn( + encryption as unknown as { bulkEncrypt: (...a: unknown[]) => unknown }, + 'bulkEncrypt', + ) + const encrypt = vi.spyOn( + encryption as unknown as { encrypt: (...a: unknown[]) => unknown }, + 'encrypt', + ) + const builder = () => + new EncryptedQueryBuilderV3Impl( + 'users', + users, + encryption, + supabase.client, + USERS_ALL_COLUMNS, + ) + return { supabase, builder, bulkEncrypt, encrypt } + } + + /** The plaintext each emitted operand actually encrypts, in call order. */ + const plaintextsOf = (calls: { args: unknown[] }[], operandIndex: number) => + calls.map((c) => JSON.parse(c.args[operandIndex] as string).pt) + + it('spends one bulk crossing on an in-list, not one per element', async () => { + const { builder, bulkEncrypt, encrypt } = batchingInstance() + + await builder().select('id').in('nickname', ['ada', 'grace', 'hopper']) + + expect(bulkEncrypt).toHaveBeenCalledTimes(1) + expect(encrypt).not.toHaveBeenCalled() + + const [payloads, opts] = bulkEncrypt.mock.calls[0] as [ + Array<{ plaintext: unknown }>, + { column: { getName(): string } }, + ] + expect(payloads).toEqual([ + { plaintext: 'ada' }, + { plaintext: 'grace' }, + { plaintext: 'hopper' }, + ]) + expect(opts.column.getName()).toBe('nickname') + }) + + it('groups a multi-column query into one crossing per column', async () => { + const { builder, bulkEncrypt } = batchingInstance() + + await builder() + .select('id') + .eq('email', 'ada@lovelace.dev') + .eq('nickname', 'ada') + .in('nickname', ['grace', 'hopper']) + + // Two columns, two crossings — NOT four terms, four crossings. + expect(bulkEncrypt).toHaveBeenCalledTimes(2) + + const byColumn = new Map( + bulkEncrypt.mock.calls.map((call) => { + const [payloads, opts] = call as [ + Array<{ plaintext: unknown }>, + { column: { getName(): string } }, + ] + return [opts.column.getName(), payloads.map((p) => p.plaintext)] + }), + ) + expect(byColumn.get('email')).toEqual(['ada@lovelace.dev']) + expect(byColumn.get('nickname')).toEqual(['ada', 'grace', 'hopper']) + }) + + // Grouping reorders the crossings; the operands must still land on the filter + // that asked for them. This is the assertion that catches a bad scatter. + it('scatters each envelope back onto its own filter', async () => { + const { supabase, builder } = batchingInstance() + + await builder() + .select('id') + .eq('email', 'ada@lovelace.dev') + .eq('nickname', 'ada') + .in('nickname', ['grace', 'hopper']) + + expect(plaintextsOf(supabase.callsFor('eq'), 1)).toEqual([ + 'ada@lovelace.dev', + 'ada', + ]) + + const inCall = supabase.callsFor('filter')[0] + expect(inCall.args[1]).toBe('in') + const elements = (inCall.args[2] as string) + .slice(1, -1) + .split(/","/) + .map((e) => JSON.parse(e.replace(/^"|"$/g, '').replace(/\\"/g, '"')).pt) + expect(elements).toEqual(['grace', 'hopper']) + }) + + it('falls back to per-term encryption when the client has no bulkEncrypt', async () => { + const supabase = createMockSupabase() + const encryption = createMockEncryptionClient() + // biome-ignore lint/performance/noDelete: exercising the capability probe + delete (encryption as unknown as { bulkEncrypt?: unknown }).bulkEncrypt + const encrypt = vi.spyOn( + encryption as unknown as { encrypt: (...a: unknown[]) => unknown }, + 'encrypt', + ) + + await new EncryptedQueryBuilderV3Impl( + 'users', + users, + encryption, + supabase.client, + USERS_ALL_COLUMNS, + ) + .select('id') + .eq('email', 'ada@lovelace.dev') + .in('nickname', ['grace', 'hopper']) + + expect(encrypt).toHaveBeenCalledTimes(3) + expect(plaintextsOf(supabase.callsFor('eq'), 1)).toEqual([ + 'ada@lovelace.dev', + ]) + }) + + it('rejects a bulk response whose length does not match the list', async () => { + const supabase = createMockSupabase() + const encryption = createMockEncryptionClient() + ;( + encryption as unknown as { bulkEncrypt: (...a: unknown[]) => unknown } + ).bulkEncrypt = () => operation([{ data: fakeEnvelope('ada', 'nickname') }]) + + const { error, status } = await new EncryptedQueryBuilderV3Impl( + 'users', + users, + encryption, + supabase.client, + USERS_ALL_COLUMNS, + ) + .select('id') + .in('nickname', ['ada', 'grace']) + + // Silently truncating would widen the `in` predicate to one element. + expect(status).toBe(500) + expect(error?.message).toMatch(/1 term(s)? for 2 value(s)?/) + }) + + it('rejects a bulk response with a null envelope rather than sending "null"', async () => { + const supabase = createMockSupabase() + const encryption = createMockEncryptionClient() + // A length-matched response, but position 0 is a null envelope. Without the + // guard, `JSON.stringify(null)` would send the literal `"null"` as the `in` + // operand — matching whatever `"null"` encodes to instead of failing. + ;( + encryption as unknown as { bulkEncrypt: (...a: unknown[]) => unknown } + ).bulkEncrypt = () => + operation([{ data: null }, { data: fakeEnvelope('grace', 'nickname') }]) + + const { error, status } = await new EncryptedQueryBuilderV3Impl( + 'users', + users, + encryption, + supabase.client, + USERS_ALL_COLUMNS, + ) + .select('id') + .in('nickname', ['ada', 'grace']) + + expect(status).toBe(500) + expect(error?.message).toMatch(/null envelope at position 0/) + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-v3-factory.test.ts b/packages/stack-supabase/__tests__/supabase-v3-factory.test.ts new file mode 100644 index 000000000..66fceb524 --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-v3-factory.test.ts @@ -0,0 +1,267 @@ +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import type { SupabaseClientLike } from '../src/index.js' +import { encryptedSupabaseV3 } from '../src/index.js' +import type { IntrospectionData } from '../src/introspect' +import { EncryptedQueryBuilderV3Impl } from '../src/query-builder-v3' + +// --- Mocks ----------------------------------------------------------------- +// +// `vi.mock` factories are hoisted above every import, so they cannot close over +// a plain top-level `const` (it would still be in its TDZ when the factory runs +// on first import). `vi.hoisted` lifts the spies alongside them. + +const { introspectMock, encryptionMock, createClientMock } = vi.hoisted(() => ({ + introspectMock: vi.fn<(url: string) => Promise>(), + encryptionMock: vi.fn<(cfg: unknown) => Promise>(), + createClientMock: vi.fn(() => ({ from: () => ({}) })), +})) + +vi.mock('../src/introspect', async (importActual) => { + const actual = await importActual() + return { ...actual, introspect: (url: string) => introspectMock(url) } +}) + +vi.mock('@cipherstash/stack/encryption', async (importActual) => { + const actual = + await importActual() + return { ...actual, Encryption: (cfg: unknown) => encryptionMock(cfg) } +}) + +vi.mock('@supabase/supabase-js', () => ({ createClient: createClientMock })) + +const fakeClient = { from: () => ({}) } as unknown as SupabaseClientLike + +function introspectionOf(data: Partial): IntrospectionData { + return { + tables: data.tables ?? [], + unmodelled: data.unmodelled ?? new Map(), + } +} + +const usersIntrospection = introspectionOf({ + tables: [ + { + tableName: 'users', + columns: [ + { columnName: 'id', domainName: null }, + { columnName: 'email', domainName: 'eql_v3_text_search' }, + ], + }, + ], +}) + +beforeEach(() => { + introspectMock.mockReset().mockResolvedValue(usersIntrospection) + encryptionMock.mockReset().mockResolvedValue({}) + createClientMock.mockClear() + delete process.env.DATABASE_URL +}) +afterEach(() => vi.restoreAllMocks()) + +describe('encryptedSupabaseV3 factory', () => { + it('url+key overload builds a client and introspects the given databaseUrl', async () => { + await encryptedSupabaseV3('http://sb', 'anon-key', { + databaseUrl: 'postgres://x', + }) + expect(createClientMock).toHaveBeenCalledWith('http://sb', 'anon-key') + expect(introspectMock).toHaveBeenCalledWith('postgres://x') + expect(encryptionMock).toHaveBeenCalledTimes(1) + }) + + it('client overload uses the supplied client (no createClient)', async () => { + await encryptedSupabaseV3(fakeClient, { databaseUrl: 'postgres://x' }) + expect(createClientMock).not.toHaveBeenCalled() + }) + + it('falls back to process.env.DATABASE_URL', async () => { + process.env.DATABASE_URL = 'postgres://env' + await encryptedSupabaseV3(fakeClient) + expect(introspectMock).toHaveBeenCalledWith('postgres://env') + }) + + it('throws naming DATABASE_URL when no URL is available', async () => { + await expect(encryptedSupabaseV3(fakeClient)).rejects.toThrow( + /DATABASE_URL/, + ) + expect(introspectMock).not.toHaveBeenCalled() + }) + + it('verifies BEFORE building the encryption client (wrong domain)', async () => { + // email is text_search in the DB; declaring text_eq must fail... + const users = encryptedTable('users', { email: types.TextEq('email') }) + await expect( + encryptedSupabaseV3(fakeClient, { + databaseUrl: 'postgres://x', + schemas: { users }, + }), + ).rejects.toThrow(/text_eq|text_search/) + // ...and Encryption must never be reached. + expect(encryptionMock).not.toHaveBeenCalled() + }) + + it('passes only non-empty tables to Encryption', async () => { + introspectMock.mockResolvedValue( + introspectionOf({ + tables: [ + { + tableName: 'users', + columns: [ + { columnName: 'email', domainName: 'eql_v3_text_search' }, + ], + }, + { + tableName: 'logs', + columns: [{ columnName: 'line', domainName: null }], + }, + ], + }), + ) + await encryptedSupabaseV3(fakeClient, { databaseUrl: 'postgres://x' }) + const arg = encryptionMock.mock.calls[0][0] as { schemas: unknown[] } + expect(arg.schemas).toHaveLength(1) + }) + + it('throws a diagnosis when no modelled EQL v3 columns exist anywhere', async () => { + introspectMock.mockResolvedValue( + introspectionOf({ + tables: [ + { + tableName: 'logs', + columns: [{ columnName: 'line', domainName: null }], + }, + ], + }), + ) + await expect( + encryptedSupabaseV3(fakeClient, { databaseUrl: 'postgres://x' }), + ).rejects.toThrow(/no EQL v3 encrypted columns found/) + expect(encryptionMock).not.toHaveBeenCalled() + }) + + it('throws from from() on an unknown table', async () => { + const supabase = await encryptedSupabaseV3(fakeClient, { + databaseUrl: 'postgres://x', + }) + expect(() => supabase.from('nope')).toThrow(/unknown table/) + }) + + it('returns a v3 builder from from() on a known table', async () => { + const supabase = await encryptedSupabaseV3(fakeClient, { + databaseUrl: 'postgres://x', + }) + expect(supabase.from('users')).toBeInstanceOf(EncryptedQueryBuilderV3Impl) + }) + + it('throws when a schemas record key ≠ its table name', async () => { + const mislabelled = encryptedTable('users', { + email: types.TextSearch('email'), + }) + await expect( + encryptedSupabaseV3(fakeClient, { + databaseUrl: 'postgres://x', + schemas: { orders: mislabelled }, + }), + ).rejects.toThrow(/orders.*users|record key/) + }) + + // An unmodelled EQL domain is a silent-leak hazard: the column stays in + // `allColumns` so `select('*')` selects it, but it never enters the encrypt + // config, so reads return raw ciphertext undecrypted. It MUST throw — but + // only for the table the caller actually touches. Scanning the whole `public` + // schema at construction bricks the adapter for every consumer of a database + // that happens to contain one such column on an unrelated table. + describe('unmodelled EQL domains', () => { + // `users` is fully modelled. `metrics.score` is not. `metrics.label` is. + const withUnmodelledMetrics = introspectionOf({ + tables: [ + { + tableName: 'users', + columns: [ + { columnName: 'id', domainName: null }, + { columnName: 'email', domainName: 'eql_v3_text_search' }, + ], + }, + { + tableName: 'metrics', + columns: [ + { columnName: 'label', domainName: 'eql_v3_text_eq' }, + { columnName: 'score', domainName: 'eql_v3_integer_ord_ope' }, + ], + }, + ], + unmodelled: new Map([ + [ + 'metrics', + [{ columnName: 'score', domainName: 'eql_v3_integer_ord_ope' }], + ], + ]), + }) + + beforeEach(() => { + introspectMock.mockResolvedValue(withUnmodelledMetrics) + }) + + it('constructs when the unmodelled column is on a table the caller never names', async () => { + await expect( + encryptedSupabaseV3(fakeClient, { databaseUrl: 'postgres://x' }), + ).resolves.toBeDefined() + expect(encryptionMock).toHaveBeenCalledTimes(1) + }) + + it('still serves a fully-modelled table from that same database', async () => { + const es = await encryptedSupabaseV3(fakeClient, { + databaseUrl: 'postgres://x', + }) + expect(() => es.from('users')).not.toThrow() + }) + + it('throws from from() naming the table, column and domain', async () => { + const es = await encryptedSupabaseV3(fakeClient, { + databaseUrl: 'postgres://x', + }) + expect(() => es.from('metrics')).toThrow( + /metrics\.score.*integer_ord_ope/, + ) + }) + + // A declared table IS named by the caller, so it is validated eagerly — + // preserving "fails at construction, not on the first query" exactly where + // the caller asked for compile-time types. + it('throws at construction when the unmodelled table is declared in schemas', async () => { + const metrics = encryptedTable('metrics', { + label: types.TextEq('label'), + }) + await expect( + encryptedSupabaseV3(fakeClient, { + databaseUrl: 'postgres://x', + schemas: { metrics }, + }), + ).rejects.toThrow(/metrics\.score.*integer_ord_ope/) + expect(encryptionMock).not.toHaveBeenCalled() + }) + }) + + // `eqlVersion` is forced, not defaulted. A caller who passes `eqlVersion: 2` + // against v3 domains would otherwise get a v2 encryption client and fail at + // runtime with a 23514 CHECK violation, far from the cause. + it('forces eqlVersion 3 over a caller-supplied config, passing other keys through', async () => { + await encryptedSupabaseV3(fakeClient, { + databaseUrl: 'postgres://x', + config: { eqlVersion: 2, workspaceCrn: 'crn:test' } as never, + }) + + const arg = encryptionMock.mock.calls[0][0] as { + config: Record + } + expect(arg.config.eqlVersion).toBe(3) + expect(arg.config.workspaceCrn).toBe('crn:test') + }) + + it('defaults config to { eqlVersion: 3 } when none is supplied', async () => { + await encryptedSupabaseV3(fakeClient, { databaseUrl: 'postgres://x' }) + + const arg = encryptionMock.mock.calls[0][0] as { config: unknown } + expect(arg.config).toEqual({ eqlVersion: 3 }) + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-v3-matrix.test.ts b/packages/stack-supabase/__tests__/supabase-v3-matrix.test.ts new file mode 100644 index 000000000..df1e0f90e --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-v3-matrix.test.ts @@ -0,0 +1,262 @@ +/** + * Type-driven Supabase v3 wire sweep — every domain, every capability tier. + * + * The hand-written wire tests (`supabase-v3-builder.test.ts`) drive only five + * of the catalog's 39 domains through `EncryptedQueryBuilderV3Impl`; the whole + * numeric family never reached the adapter at all. This file closes that by + * reusing the SAME compile-enforced catalog (`v3-matrix/catalog.ts`) the + * Drizzle live suite tiers off, so adding a domain to the SDK yields a Supabase + * wire assertion for free — or fails to compile until it does. + * + * Tiers are derived from `indexes` exactly as `drizzle-v3/operators-live-pg. + * test.ts` derives them, rather than from `capabilities`. The adapter's guard + * reads `capabilities`, so deriving the tier from the other field makes a + * future capability/index divergence surface here as a tier mismatch instead of + * silently agreeing with itself. + * + * Only the WIRE ENCODING is under test — the mock client records `{method, + * args}` and no SQL runs. `supabase-v3-operators-live-pg.test.ts` is what + * proves Postgres accepts what this file pins. + */ + +import type { AnyV3Table } from '@cipherstash/stack/eql/v3' +import { encryptedTable } from '@cipherstash/stack/eql/v3' +import { + type DomainSpec, + type EqlV3TypeName, + eqlTypeSlug as slug, + typedEntries, + V3_MATRIX, +} from '@cipherstash/test-kit/catalog' +import { describe, expect, it } from 'vitest' +import { EncryptedQueryBuilderV3Impl } from '../src/query-builder-v3' +import { + createMockEncryptionClient, + createMockSupabase, + isFakeEnvelope, +} from './helpers/supabase-mock' + +const matrixEntries = typedEntries(V3_MATRIX) + +// Tiering, mirroring `drizzle-v3/operators-live-pg.test.ts`. +const equalityDomains = matrixEntries.filter( + ([, spec]) => spec.indexes.unique || spec.indexes.ore || spec.indexes.ope, +) +const orderDomains = matrixEntries.filter( + ([, spec]) => spec.indexes.ore || spec.indexes.ope, +) +const matchDomains = matrixEntries.filter(([, spec]) => spec.indexes.match) +/** No index at all — the `public.eql_v3_boolean`/`public.eql_v3_text`/… storage-only domains. */ +const storageOnlyDomains = matrixEntries.filter( + ([, spec]) => + !spec.indexes.unique && + !spec.indexes.ore && + !spec.indexes.ope && + !spec.indexes.match, +) + +/** + * One table per domain, property name == DB name (`builder(slug(eqlType))`) — + * the shape introspection synthesizes. Renames are covered by the declared + * `users` table in `supabase-v3-builder.test.ts`. + */ +function tableFor(eqlType: EqlV3TypeName, spec: DomainSpec): AnyV3Table { + const name = slug(eqlType) + return encryptedTable('matrix', { + [name]: spec.builder(name), + }) as unknown as AnyV3Table +} + +function instanceFor( + eqlType: EqlV3TypeName, + spec: DomainSpec, + resultData: unknown = [], +) { + const supabase = createMockSupabase(resultData) + const builder = new EncryptedQueryBuilderV3Impl( + 'matrix', + tableFor(eqlType, spec), + createMockEncryptionClient(), + supabase.client, + null, + ) + // The typed surface is keyed by the declared row type; these tests address + // columns by a runtime-computed slug and deliberately reach past it (the + // storage-only tier exists to prove the RUNTIME guard fires). + // biome-ignore lint/suspicious/noExplicitAny: see above + return { q: builder as any, supabase, name: slug(eqlType) } +} + +/** `samples[0]`, asserted non-null: a null operand short-circuits encryption + * entirely (`isEncryptableTerm`), so a future null sample would silently turn + * the capability-guard tier below into a no-op that passes for the wrong + * reason. Fail loudly instead. */ +function firstSample(spec: DomainSpec): unknown { + const sample = spec.samples[0] + expect(sample).not.toBeNull() + expect(sample).not.toBeUndefined() + return sample +} + +describe('supabase v3 wire encoding, every domain', () => { + // Guards the tier arithmetic itself. A domain silently dropping out of a + // tier would otherwise just shrink an `it.each` with no test turning red. + it('tiers all 40 domains', () => { + expect(matrixEntries).toHaveLength(40) + expect(equalityDomains).toHaveLength(28) + expect(orderDomains).toHaveLength(19) + expect(matchDomains).toHaveLength(2) + // +1: `eql_v3_json` carries only an `ste_vec` index, so from this scalar + // tiering it reads as storage-only — the Supabase adapter has no JSON + // containment path (PostgREST can't cast/call), so it rejects scalar ops. + expect(storageOnlyDomains).toHaveLength(11) + }) + + describe.each(matrixEntries)('%s', (eqlType, spec) => { + it('inserts a raw envelope keyed by the column name (no composite wrap)', async () => { + const { q, supabase, name } = instanceFor(eqlType, spec) + + await q.insert({ [name]: firstSample(spec) }) + + const [insert] = supabase.callsFor('insert') + const body = insert.args[0] as Record + expect(Object.keys(body)).toEqual([name]) + expect(isFakeEnvelope(body[name])).toBe(true) + // v2 wraps in `{ data: … }`; the v3 domains are `DOMAIN … AS jsonb`. + expect((body[name] as Record).data).toBeUndefined() + }) + + it('adds a ::jsonb cast in select', async () => { + const { q, supabase, name } = instanceFor(eqlType, spec) + + await q.select(`id, ${name}`) + + expect(supabase.callsFor('select')[0].args[0]).toBe(`id, ${name}::jsonb`) + }) + }) + + describe.each(equalityDomains)('%s (equality)', (eqlType, spec) => { + it('encrypts an eq() operand as a full-envelope jsonb string', async () => { + const { q, supabase, name } = instanceFor(eqlType, spec) + + await q.select(`id, ${name}`).eq(name, firstSample(spec)) + + const [eq] = supabase.callsFor('eq') + expect(eq.args[0]).toBe(name) + // The FULL storage envelope, not a narrowed `encryptQuery` term: the + // `public.*` domain CHECK requires `v`/`i`/`c`. + expect(JSON.parse(eq.args[1] as string).c).toBeDefined() + }) + }) + + describe.each(orderDomains)('%s (orderAndRange)', (eqlType, spec) => { + it('encrypts a gte() operand as a full-envelope jsonb string', async () => { + const { q, supabase, name } = instanceFor(eqlType, spec) + + await q.select(`id, ${name}`).gte(name, firstSample(spec)) + + const [gte] = supabase.callsFor('gte') + expect(gte.args[0]).toBe(name) + expect(JSON.parse(gte.args[1] as string).c).toBeDefined() + }) + + // A bare `ORDER BY col` WOULD be wrong — no btree operator class exists on + // any EQL v3 domain, so it falls through to jsonb's default opclass and + // sorts the ciphertext envelope. The builder never emits one. For an + // OPE-backed column it emits the jsonb path `col->>op`, which selects the + // order-preserving term. For an ORE-backed column there is no such path — + // `ob` is an array of blocks needing the superuser-only comparator — so it + // is refused. + if (spec.indexes.ope) { + it('orders by the OPE term, not by the envelope', async () => { + const { q, supabase, name } = instanceFor(eqlType, spec) + + const { error } = await q.select(`id, ${name}`).order(name) + + expect(error).toBeNull() + const [order] = supabase.callsFor('order') + expect(order.args[0]).toBe(`${name}->op`) + }) + } else { + it('rejects order() even though gte() is supported', async () => { + const { q, supabase, name } = instanceFor(eqlType, spec) + + const { error, status } = await q.select(`id, ${name}`).order(name) + + expect(status).toBe(500) + expect(error?.message).toContain('cannot order by encrypted column') + expect(error?.message).toContain('ORE ordering term') + expect(supabase.callsFor('order')).toHaveLength(0) + }) + } + }) + + describe.each(matchDomains)('%s (freeTextSearch)', (eqlType, spec) => { + it('emits matches() as a cs containment filter', async () => { + const { q, supabase, name } = instanceFor(eqlType, spec) + + await q.select(`id, ${name}`).matches(name, firstSample(spec)) + + const [filter] = supabase.callsFor('filter') + expect(filter.args[0]).toBe(name) + expect(filter.args[1]).toBe('cs') + expect(JSON.parse(filter.args[2] as string).c).toBeDefined() + // The v3 domains define no LIKE operator — a bare `like` would 42883. + expect(supabase.callsFor('like')).toHaveLength(0) + }) + + it('refuses contains(), directing the caller to matches()', async () => { + const { q, name } = instanceFor(eqlType, spec) + + expect(() => q.contains(name, firstSample(spec))).toThrow( + /Use matches\(\)/, + ) + }) + + // like/ilike on an encrypted free-text column are an approximate shim that + // DELEGATES to matches: a wildcard-free sample is fuzzy-matched, emitting the + // same `cs` wire as matches() (#617). (These matrix samples carry no `%`/`_`.) + it('delegates like() to matches, emitting the same cs filter', async () => { + const { q, supabase, name } = instanceFor(eqlType, spec) + + await q.select(`id, ${name}`).like(name, firstSample(spec) as string) + + const [filter] = supabase.callsFor('filter') + expect(filter.args[0]).toBe(name) + expect(filter.args[1]).toBe('cs') + expect(JSON.parse(filter.args[2] as string).c).toBeDefined() + expect(supabase.callsFor('like')).toHaveLength(0) + }) + }) + + describe.each(storageOnlyDomains)('%s (storage only)', (eqlType, spec) => { + it('rejects eq() with the equality capability message', async () => { + const { q, name } = instanceFor(eqlType, spec) + + const { error, status } = await q.select('id').eq(name, firstSample(spec)) + + expect(status).toBe(500) + expect(error?.message).toContain('does not support equality') + }) + + it('rejects gte() with the orderAndRange capability message', async () => { + const { q, name } = instanceFor(eqlType, spec) + + const { error, status } = await q + .select('id') + .gte(name, firstSample(spec)) + + expect(status).toBe(500) + expect(error?.message).toContain('does not support orderAndRange') + }) + + it('rejects order() with the encrypted-ordering message', async () => { + const { q, name } = instanceFor(eqlType, spec) + + const { error, status } = await q.select('id').order(name) + + expect(status).toBe(500) + expect(error?.message).toContain('cannot order by encrypted column') + }) + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-v3-select-star.test.ts b/packages/stack-supabase/__tests__/supabase-v3-select-star.test.ts new file mode 100644 index 000000000..1fd76f220 --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-v3-select-star.test.ts @@ -0,0 +1,195 @@ +import type { EncryptionClient } from '@cipherstash/stack/encryption' +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { describe, expect, it } from 'vitest' +import { EncryptedQueryBuilderV3Impl } from '../src/query-builder-v3' + +/** + * Supabase double that records the select string AND simulates the part of + * PostgREST this adapter depends on: a `alias:column::jsonb` token returns the + * value under `alias`, a bare `column::jsonb` (or `column`) under `column`. + * + * Simulating the rename is the point. The alias is the ONLY thing that makes a + * renamed column come back under its JS property name, and it is produced + * server-side — a double that echoes rows verbatim would assert nothing about + * it. `dbRows` are keyed by DB column name, exactly as Postgres stores them. + */ +function mockSupabase(dbRows: Record[] = []) { + const selects: string[] = [] + + const project = (select: string) => + dbRows.map((dbRow) => { + const row: Record = {} + for (const token of select.split(',')) { + const bare = token.trim().replace(/::jsonb$/, '') + const [alias, column] = bare.includes(':') + ? bare.split(':') + : [bare, bare] + row[alias] = dbRow[column] + } + return row + }) + + // biome-ignore lint/suspicious/noExplicitAny: test double + const qb: any = { + select: (s: string) => { + selects.push(s) + return qb + }, + then: ( + onfulfilled?: ((v: unknown) => unknown) | null, + onrejected?: ((r: unknown) => unknown) | null, + ) => + Promise.resolve({ + data: project(selects[0] ?? ''), + error: null, + count: null, + status: 200, + statusText: 'OK', + }).then(onfulfilled, onrejected), + } + return { client: { from: () => qb }, selects } +} + +/** Identity decrypt — this suite is about column naming, not envelopes. */ +function mockEncryptionClient() { + const operation = (data: T) => ({ + withLockContext: () => operation(data), + audit: () => operation(data), + then: (f?: ((v: { data: T }) => unknown) | null) => + Promise.resolve({ data }).then(f), + }) + return { + decryptModel: (m: Record) => operation(m), + bulkDecryptModels: (m: Record[]) => operation(m), + } as unknown as EncryptionClient +} + +const users = encryptedTable('users', { + email: types.TextSearch('email'), + amount: types.IntegerOrd('amount'), + createdAt: types.TimestampOrd('created_at'), +}) + +// DB column names as introspection would report them (plaintext id/note included). +const ALL_COLUMNS = ['id', 'email', 'amount', 'created_at', 'note'] + +function builderFor( + supabase: ReturnType, + allColumns: string[] | null = ALL_COLUMNS, +) { + return new EncryptedQueryBuilderV3Impl( + 'users', + users, + mockEncryptionClient(), + supabase.client, + allColumns, + ) +} + +describe("v3 select('*') expansion", () => { + it('expands * to the full column list and casts encrypted columns', async () => { + const supabase = mockSupabase() + await builderFor(supabase).select('*') + + // `created_at` is aliased back to its JS property name; `id`/`note` are + // plaintext passthrough and `email`/`amount` are named identically in both. + expect(supabase.selects[0]).toBe( + 'id, email::jsonb, amount::jsonb, createdAt:created_at::jsonb, note', + ) + }) + + it('no-arg select() behaves exactly like select("*")', async () => { + const supabase = mockSupabase() + await builderFor(supabase).select() + + expect(supabase.selects[0]).toBe( + 'id, email::jsonb, amount::jsonb, createdAt:created_at::jsonb, note', + ) + }) + + it("still throws select('*') when no column list is available", async () => { + const supabase = mockSupabase() + const builder = builderFor(supabase, null) + + expect(() => builder.select('*')).toThrow(/select\('\*'\)/) + // v2 regression: a bare select() takes the same path and throws the same way. + expect(() => builder.select()).toThrow(/select\('\*'\)/) + }) + + it("throws select('*') for an empty column list, not an empty select", async () => { + // The guard is `=== null || .length === 0`. Only the null arm has a caller + // today (`index.ts` passes `?? null`), so nothing stops a future `?? []` + // from turning an unusable `*` into a silent zero-column select. + const supabase = mockSupabase() + const builder = builderFor(supabase, []) + + expect(() => builder.select('*')).toThrow(/select\('\*'\)/) + expect(() => builder.select()).toThrow(/select\('\*'\)/) + }) +}) + +describe("REGRESSION: select('*') keys rows by JS property, not DB column", () => { + // A declared column whose property name differs from its DB column is the + // only case that can drift: synthesized columns always have property == DB + // name. Before the `expandAllColumns` override, `select('*')` emitted the + // unaliased `created_at::jsonb`, so rows came back keyed `created_at` while + // the declared row type promises `createdAt` — `row.createdAt` was silently + // `undefined` for a field TypeScript guaranteed as a Date. + const dbRow = { + id: 1, + email: 'a@b.com', + amount: 30, + created_at: '2026-01-02T03:04:05.000Z', + note: 'hi', + } + + it('returns the renamed column under its property name', async () => { + const supabase = mockSupabase([dbRow]) + const { data } = await builderFor(supabase).select('*') + + expect(data![0].createdAt).toBeInstanceOf(Date) + expect((data![0].createdAt as Date).toISOString()).toBe( + '2026-01-02T03:04:05.000Z', + ) + expect(data![0]).not.toHaveProperty('created_at') + }) + + it("select('*') and an explicit property select agree on row shape", async () => { + const star = mockSupabase([dbRow]) + const explicit = mockSupabase([dbRow]) + + const { data: starData } = await builderFor(star).select('*') + const { data: explicitData } = await builderFor(explicit).select( + 'id, email, amount, createdAt, note', + ) + + expect(Object.keys(starData![0]).sort()).toEqual( + Object.keys(explicitData![0]).sort(), + ) + expect(starData![0]).toEqual(explicitData![0]) + }) + + it('leaves plaintext passthrough columns under their DB name', async () => { + const supabase = mockSupabase([dbRow]) + const { data } = await builderFor(supabase).select('*') + + expect(data![0].id).toBe(1) + expect(data![0].note).toBe('hi') + }) + + it('does not treat a DB column named like an Object.prototype member as a property', async () => { + // `dbToProp['constructor']` would resolve to Object.prototype.constructor on + // a plain object, emitting a function where a column name belongs. + const supabase = mockSupabase() + const builder = new EncryptedQueryBuilderV3Impl( + 'weird', + encryptedTable('weird', { email: types.TextSearch('email') }), + mockEncryptionClient(), + supabase.client, + ['constructor', 'toString', 'email'], + ) + await builder.select('*') + + expect(supabase.selects[0]).toBe('constructor, toString, email::jsonb') + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-v3-wire.test.ts b/packages/stack-supabase/__tests__/supabase-v3-wire.test.ts new file mode 100644 index 000000000..61953f6a7 --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-v3-wire.test.ts @@ -0,0 +1,217 @@ +/** + * Wire-format tests: what PostgREST actually receives. + * + * These drive the real postgrest-js serializer (see `helpers/postgrest-wire`), + * because the encrypted operand is `JSON.stringify(envelope)` — dense with `"` + * and `,` — and postgrest-js's `in()`/`notIn()` wrap a comma-bearing element in + * `"…"` WITHOUT escaping the quotes already inside it. The mock-based suites + * assert the array handed to `.in()` and cannot see that. + */ + +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { describe, expect, it } from 'vitest' +import { EncryptedQueryBuilderV3Impl } from '../src/query-builder-v3' +import { createWirePostgrest } from './helpers/postgrest-wire' +import { createMockEncryptionClient } from './helpers/supabase-mock' + +const users = encryptedTable('users', { + email: types.TextSearch('email'), + nickname: types.TextEq('nickname'), +}) + +const ALL_COLUMNS = ['id', 'email', 'nickname', 'note'] + +function wireInstance() { + const wire = createWirePostgrest([]) + const builder = () => + new EncryptedQueryBuilderV3Impl( + 'users', + users, + createMockEncryptionClient(), + wire.client, + ALL_COLUMNS, + ) + return { wire, builder } +} + +/** + * Split a PostgREST `(a,b)` list the way the server does: a `\` escapes the + * next character, and a top-level `,` only separates when not inside quotes. + * Returns each element with its quoting and escaping undone. + */ +function parseInList(operand: string, prefix: string): string[] { + expect(operand.startsWith(`${prefix}.(`)).toBe(true) + expect(operand.endsWith(')')).toBe(true) + const inner = operand.slice(`${prefix}.(`.length, -1) + + const out: string[] = [] + let cur = '' + let quoted = false + let escaped = false + for (const ch of inner) { + if (escaped) { + cur += ch + escaped = false + } else if (ch === '\\') { + escaped = true + } else if (ch === '"') { + quoted = !quoted + } else if (ch === ',' && !quoted) { + out.push(cur) + cur = '' + } else { + cur += ch + } + } + out.push(cur) + return out +} + +describe('encrypted in() emits a parseable PostgREST operand', () => { + it('escapes the quotes inside each encrypted element', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').in('nickname', ['ada', 'grace']) + + const operand = wire.operandFor('nickname') + // Unescaped, PostgREST terminates the value at the envelope's first `"`. + expect(operand).toContain('\\"') + + const elements = parseInList(operand, 'in') + expect(elements).toHaveLength(2) + const plaintexts = elements.map((e) => JSON.parse(e).pt) + expect(plaintexts).toEqual(['ada', 'grace']) + }) + + it('leaves a plaintext in() list alone', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').in('note', ['x', 'y']) + + expect(wire.operandFor('note')).toBe('in.(x,y)') + }) +}) + +describe('encrypted not(col, in, …) emits a parseable PostgREST operand', () => { + it('encrypts each element separately and escapes them', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').not('nickname', 'in', ['ada', 'grace']) + + const operand = wire.operandFor('nickname') + expect(operand.startsWith('not.in.(')).toBe(true) + + const elements = parseInList(operand, 'not.in') + expect(elements).toHaveLength(2) + const plaintexts = elements.map((e) => JSON.parse(e).pt) + // The whole array must never be encrypted as ONE ciphertext. + expect(plaintexts).toEqual(['ada', 'grace']) + }) + + it('leaves a plaintext not-in list alone', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').not('note', 'in', ['x', 'y']) + + expect(wire.operandFor('note')).toBe('not.in.(x,y)') + }) + + // A PostgREST list literal cannot be encrypted element-wise, and encrypting + // it whole silently matches nothing. Fail loudly instead. + it('rejects a PostgREST list literal on an encrypted column', async () => { + const { builder } = wireInstance() + + const { error, status } = await builder() + .select('id') + .not('nickname', 'in', '(ada,grace)') + + expect(status).toBe(500) + expect(error?.message).toMatch(/requires an array of values/) + }) +}) + +// postgrest-js serializes a `contains` array as `cs.{${value.join(',')}}` — no +// element quoting — and a `not(col, 'contains', …)` operand as a bare +// `String(value)` coercion, which loses the braces entirely and renders an object +// as `[object Object]`. The `.or()` path already formats containment operands +// correctly; these are the direct paths, and they disagreed with it. +describe('plaintext contains() emits a parseable containment literal', () => { + it('quotes an array element containing a comma', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').contains('note', ['with,comma']) + + // Unquoted, Postgres reads `{with,comma}` as TWO elements. + expect(wire.operandFor('note')).toBe('cs.{"with,comma"}') + }) + + it('leaves a comma-free array operand as a bare array literal', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').contains('note', ['vip', 'admin']) + + expect(wire.operandFor('note')).toBe('cs.{vip,admin}') + }) + + it('emits a jsonb literal for an object operand', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').contains('note', { a: 1 }) + + expect(wire.operandFor('note')).toBe('cs.{"a":1}') + }) + + it('forwards a string operand verbatim', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').contains('note', 'plain') + + expect(wire.operandFor('note')).toBe('cs.plain') + }) + + // An empty element is not an empty array: `{}` is a zero-length array literal, + // so the containment would test for nothing at all. + it('quotes an empty array element', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').contains('note', ['']) + + expect(wire.operandFor('note')).toBe('cs.{""}') + }) + + // `NULL` is a keyword inside an array literal, case-insensitively. A string + // that spells it must be quoted or the element becomes a SQL NULL. + it('quotes an element spelling null', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').contains('note', ['null']) + + expect(wire.operandFor('note')).toBe('cs.{"null"}') + }) +}) + +describe('plaintext not(col, contains, …) emits a parseable containment literal', () => { + it('quotes an array element containing a comma', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').not('note', 'contains', ['with,comma']) + + expect(wire.operandFor('note')).toBe('not.cs.{"with,comma"}') + }) + + it('emits a jsonb literal for an object operand', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').not('note', 'contains', { a: 1 }) + + expect(wire.operandFor('note')).toBe('not.cs.{"a":1}') + }) + + it('emits the `cs` token, never the `contains` method name', async () => { + const { wire, builder } = wireInstance() + + await builder().select('id').not('note', 'contains', ['vip']) + + expect(wire.operandFor('note')).toBe('not.cs.{vip}') + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-v3.test-d.ts b/packages/stack-supabase/__tests__/supabase-v3.test-d.ts new file mode 100644 index 000000000..10ab39b2d --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-v3.test-d.ts @@ -0,0 +1,357 @@ +import { + encryptedTable, + type InferPlaintext, + types, +} from '@cipherstash/stack/eql/v3' +import { + encryptedColumn, + encryptedTable as v2EncryptedTable, +} from '@cipherstash/stack/schema' +import { describe, expectTypeOf, it } from 'vitest' +import { + type EncryptedQueryBuilderV3, + type EncryptedSupabaseResponse, + encryptedSupabase, + encryptedSupabaseV3, + type SupabaseClientLike, +} from '../src/index.js' + +declare const supabaseClient: SupabaseClientLike + +const users = encryptedTable('users', { + email: types.TextSearch('email'), + amount: types.IntegerOrd('amount'), + createdAt: types.TimestampOrd('created_at'), + active: types.Boolean('active'), + nickname: types.TextEq('nickname'), + bio: types.TextMatch('bio'), + score: types.IntegerOrdOre('score'), +}) + +type UserRow = InferPlaintext + +/** + * A declared table whose ROW also carries plaintext passthrough columns — + * `tags` (text[]), `meta` (jsonb) and `note` (a SCALAR text column). + * `InferPlaintext` alone yields only the declared encrypted columns, so this is + * the shape that exercises the plaintext half of `V3FreeTextSearchableKeys`. + */ +declare const mixedBuilder: EncryptedQueryBuilderV3< + typeof users, + UserRow & { tags: string[]; meta: Record; note: string } +> + +/** A column key that is a UNION spanning an encrypted and a plaintext column. */ +declare const mixedKey: 'email' | 'tags' +/** A column key that is a union of plaintext columns only. */ +declare const plaintextKey: 'tags' | 'meta' + +describe('encryptedSupabaseV3 typed surface (with schemas)', () => { + it('rows carry each column its domain plaintext type', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const { data } = await supabase.from('users').select('id, email, amount') + expectTypeOf(data![0].email).toEqualTypeOf() + expectTypeOf(data![0].amount).toEqualTypeOf() + expectTypeOf(data![0].createdAt).toEqualTypeOf() + expectTypeOf(data![0].active).toEqualTypeOf() + }) + + it('pins filter value types to the column plaintext', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + builder.eq('email', 'a@b.com') + builder.gte('amount', 10) + builder.gte('createdAt', new Date()) + // @ts-expect-error — email is a string column + builder.eq('email', 42) + // @ts-expect-error — amount is a number column + builder.gte('amount', 'ten') + }) + + it('rejects filters on storage-only columns at the type level', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + // @ts-expect-error — active is public.eql_v3_boolean (storage only) + builder.eq('active', true) + // @ts-expect-error — you cannot IS TRUE-compare a ciphertext to a plaintext + builder.is('active', true) + }) + + // Every encrypted column stores a jsonb envelope, whether or not it carries a + // query capability. `IS TRUE` compares that envelope to a plaintext boolean — + // a database type error, not a filter. Gating the boolean form on the + // FILTERABLE keys only excluded the storage-only columns, so a queryable + // encrypted column like `email` slipped through. + it('rejects is(col, true) on queryable encrypted columns', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + // @ts-expect-error — email is public.eql_v3_text_search: a jsonb ciphertext + builder.is('email', true) + // @ts-expect-error — nickname is public.eql_v3_text_eq: a jsonb ciphertext + builder.is('nickname', false) + // @ts-expect-error — amount is public.eql_v3_integer_ord: a jsonb ciphertext + builder.is('amount', true) + }) + + // `IS NULL` is forwarded unencrypted (a NULL plaintext is stored as a SQL + // NULL, not a ciphertext), and it is the ONLY predicate a storage-only column + // supports — so it must not be gated behind the filterable-key narrowing. + it('allows is(col, null) on every column, including storage-only ones', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + builder.is('active', null) + builder.is('email', null) + }) + + it('allows order() on encrypted columns that carry an ordering term', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + // The builder does not emit a bare `ORDER BY col` — that would sort the + // ciphertext envelope through jsonb's default opclass. It emits the jsonb + // path `col->>op`, which selects the OPE term, and OPE is order-preserving. + builder.order('createdAt') + builder.order('amount', { ascending: false }) + // `text_search` carries `ope` alongside its match and equality terms. + builder.order('email') + }) + + it('rejects order() on encrypted columns with no ordering term', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + // @ts-expect-error — active is public.eql_v3_boolean: storage only + builder.order('active') + // @ts-expect-error — nickname is public.eql_v3_text_eq: equality only + builder.order('nickname') + // @ts-expect-error — bio is public.eql_v3_text_match: match only + builder.order('bio') + // @ts-expect-error — score is public.eql_v3_integer_ord_ore: ORE-backed, so + // orderAndRange-capable but NOT sortable through a jsonb path (its `ob` term + // needs the superuser-only ORE opclass). Excluded at compile time to match + // the runtime rejection. + builder.order('score') + }) + + it('still allows order() on a plaintext row key', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + // `note` is not a declared column, so it is a plaintext passthrough. + const builder = supabase.from<{ note: string }>('users') + builder.order('note') + }) + + it('narrows matches() to freeTextSearch-capable columns', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + // public.eql_v3_text_search — equality + orderAndRange + freeTextSearch + builder.matches('email', 'ada') + // public.eql_v3_text_match — freeTextSearch only + builder.matches('bio', 'ada') + // @ts-expect-error — nickname is public.eql_v3_text_eq: no match index + builder.matches('nickname', 'ada') + // @ts-expect-error — amount is public.eql_v3_integer_ord: no match index + builder.matches('amount', 'ada') + // @ts-expect-error — active is public.eql_v3_boolean (storage only) + builder.matches('active', 'ada') + }) + + // `matches()` is encrypted free-text ONLY: its operand is the string to + // tokenize, and a plaintext key is a compile error (use `contains()`). + it('pins the matches() operand to a string on encrypted columns', () => { + mixedBuilder.matches('email', 'ada') + mixedBuilder.matches('bio', 'ada') + // @ts-expect-error — email is public.eql_v3_text_search: the match term is a string + mixedBuilder.matches('email', ['ada']) + // @ts-expect-error — bio is public.eql_v3_text_match: the match term is a string + mixedBuilder.matches('bio', { a: 1 }) + }) + + it('rejects matches() on plaintext keys — use contains()', () => { + // @ts-expect-error — tags is plaintext; matches() is encrypted free-text only + mixedBuilder.matches('tags', 'vip') + // @ts-expect-error — meta is plaintext; matches() is encrypted free-text only + mixedBuilder.matches('meta', 'vip') + // @ts-expect-error — a union with a plaintext member is not free-text-only + mixedBuilder.matches(plaintextKey, 'vip') + // @ts-expect-error — a mixed union (encrypted + plaintext) is not free-text-only + mixedBuilder.matches(mixedKey, 'ada') + }) + + // `contains()` is native (exact) containment on PLAINTEXT columns; the operand + // follows the column shape (`@>` is array/jsonb only). An encrypted key is a + // compile error (use `matches()`). + it('accepts native containment operand shapes via contains()', () => { + mixedBuilder.contains('tags', ['vip']) + mixedBuilder.contains('tags', 'vip') + mixedBuilder.contains('meta', { plan: 'pro' }) + mixedBuilder.contains(plaintextKey, ['vip']) + mixedBuilder.contains(plaintextKey, { plan: 'pro' }) + }) + + it('rejects contains() on encrypted keys — use matches()', () => { + // @ts-expect-error — email is encrypted; contains() is native (plaintext) only + mixedBuilder.contains('email', 'ada') + // @ts-expect-error — bio is encrypted; contains() is native (plaintext) only + mixedBuilder.contains('bio', 'ada') + // @ts-expect-error — a mixed union includes the encrypted email + mixedBuilder.contains(mixedKey, ['vip']) + }) + + // `@>` is defined on arrays and jsonb, not on a scalar, so the operand type + // must follow the column's own shape rather than admitting every native + // containment value on every plaintext key. + it('rejects a container operand on a plaintext scalar column', () => { + // @ts-expect-error — note is plaintext text: `text @> text[]` does not exist + mixedBuilder.contains('note', ['vip']) + // @ts-expect-error — note is plaintext text: `text @> jsonb` does not exist + mixedBuilder.contains('note', { a: 1 }) + // @ts-expect-error — a scalar column supports no container operand at all + mixedBuilder.contains('note', 'vip') + }) + + it('does not expose like/ilike on the v3 builder, at any chain depth', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + // @ts-expect-error — v3 free-text search is token containment: use matches() + builder.like('email', '%ada%') + // @ts-expect-error — v3 free-text search is token containment: use matches() + builder.ilike('email', '%ada%') + // The chain must not launder the removal back in via a widened return type. + // @ts-expect-error — use matches() + builder.select('id').eq('email', 'a@b.com').like('email', '%ada%') + // matches() survives the chain. + builder.select('id').eq('email', 'a@b.com').matches('email', 'ada') + }) + + it('accepts plaintext model values on insert', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + builder.insert({ email: 'a@b.com', amount: 3, createdAt: new Date() }) + // @ts-expect-error — createdAt is a Date column + builder.insert({ createdAt: 'not-a-date' }) + }) + + it('resolves responses to the row type', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + expectTypeOf( + supabase.from('users').select('id, email'), + ).resolves.toEqualTypeOf>() + }) + + it('keeps undeclared tables reachable on the untyped surface (the gradient)', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + // `orders` was introspected but not declared. It MUST still compile, falling + // through to the untyped `from(table: string)` overload — declaring one + // table must not make every other table unreachable. + const builder = supabase.from('orders') + builder.eq('anything', 1) + const { data } = await builder.select('id') + expectTypeOf(data![0]).toEqualTypeOf>() + }) + + it('rejects a v2 table in schemas', async () => { + const v2Table = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + // The directive sits on the call, not the property: no overload accepts a + // v2 table, so TypeScript reports the failure at the call expression. + // @ts-expect-error — schemas only accepts v3 tables + await encryptedSupabaseV3(supabaseClient, { + schemas: { users: v2Table }, + }) + }) +}) + +describe('encryptedSupabaseV3 untyped surface (no schemas)', () => { + it('rows default to Record and from accepts any string', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient) + const builder = supabase.from('anything') + const { data } = await builder.select('id, email') + expectTypeOf(data![0]).toEqualTypeOf>() + builder.eq('whatever', 123) + }) + + it('accepts an explicit row generic', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient) + const builder = supabase.from<{ id: number; email: string }>('users') + builder.eq('email', 'a@b.com') + builder.eq('id', 1) + // @ts-expect-error — not a row key + builder.eq('missing', 1) + }) + + it('exposes matches and contains, but not like/ilike', async () => { + // Without `schemas` there is no capability information, so neither `matches` + // nor `contains` can be narrowed — but the DIALECT is still v3, so + // `like`/`ilike` must be gone. Otherwise the untyped surface silently hands + // back the v2 builder type. The untyped v3 builder exposes BOTH the encrypted + // free-text `matches` and the native `contains`. + const supabase = await encryptedSupabaseV3(supabaseClient) + const builder = supabase.from<{ id: number; email: string }>('users') + builder.matches('email', 'ada') + builder.contains('email', 'ada') + // @ts-expect-error — v3 free-text search is token containment: use matches() + builder.like('email', '%ada%') + // @ts-expect-error — v3 free-text search is token containment: use matches() + builder.ilike('email', '%ada%') + }) + + // No `schemas` means no capability information, so nothing here can tell an + // encrypted match column from a plaintext jsonb one. The operand must accept + // both — the runtime decides which by looking the column up. + it('accepts native containment operands, having no capability info to narrow with', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient) + const builder = supabase.from<{ + id: number + tags: string[] + meta: Record + }>('users') + builder.contains('tags', ['vip']) + builder.contains('meta', { plan: 'pro' }) + builder.contains('tags', 'vip') + }) + + it('keeps like/ilike on the v2 builder', () => { + const v2Users = v2EncryptedTable('users', { + email: encryptedColumn('email').freeTextSearch(), + }) + const v2 = encryptedSupabase({ + encryptionClient: {} as never, + supabaseClient, + }) + const builder = v2.from<{ email: string }>('users', v2Users) + builder.like('email', '%ada%') + builder.ilike('email', '%ada%') + // @ts-expect-error — contains is the v3 dialect's method + builder.contains('email', 'ada') + }) + + it('supports a no-arg select(), like supabase-js', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient) + supabase.from('users').select() + }) +}) diff --git a/packages/stack-supabase/__tests__/supabase-verify.test.ts b/packages/stack-supabase/__tests__/supabase-verify.test.ts new file mode 100644 index 000000000..c0e08260c --- /dev/null +++ b/packages/stack-supabase/__tests__/supabase-verify.test.ts @@ -0,0 +1,88 @@ +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { describe, expect, it } from 'vitest' +import type { IntrospectionResult } from '../src/introspect' +import { verifyDeclaredSchemas } from '../src/verify' + +const introspection: IntrospectionResult = [ + { + tableName: 'users', + columns: [ + { columnName: 'id', domainName: null }, + { columnName: 'email', domainName: 'eql_v3_text_search' }, + { columnName: 'amount', domainName: 'eql_v3_integer_ord' }, + ], + }, +] + +describe('verifyDeclaredSchemas', () => { + it('passes when every declared column matches its introspected domain', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + amount: types.IntegerOrd('amount'), + }) + expect(() => verifyDeclaredSchemas({ users }, introspection)).not.toThrow() + }) + + it('passes when only a subset of encrypted columns is declared', () => { + const users = encryptedTable('users', { email: types.TextSearch('email') }) + expect(() => verifyDeclaredSchemas({ users }, introspection)).not.toThrow() + }) + + it('throws naming the table when a declared table is absent', () => { + const orders = encryptedTable('orders', { + total: types.IntegerOrd('total'), + }) + expect(() => verifyDeclaredSchemas({ orders }, introspection)).toThrow( + /table "orders"/, + ) + }) + + it('throws naming the column when a declared column is absent', () => { + const users = encryptedTable('users', { missing: types.TextEq('missing') }) + expect(() => verifyDeclaredSchemas({ users }, introspection)).toThrow( + /users\.missing/, + ) + }) + + it('throws naming both domains when the domain differs', () => { + // email is actually text_search; declaring text_eq must fail at startup. + const users = encryptedTable('users', { email: types.TextEq('email') }) + expect(() => verifyDeclaredSchemas({ users }, introspection)).toThrow( + /text_eq.*text_search|text_search.*text_eq/, + ) + }) + + // The `actual ?? '(none)'` arm: `id` exists but carries no domain. Declaring + // it encrypted must fail at construction, not as a 23514 CHECK violation on + // the first insert. + it('throws "(none)" when a declared column is plaintext in the database', () => { + const users = encryptedTable('users', { id: types.IntegerEq('id') }) + expect(() => verifyDeclaredSchemas({ users }, introspection)).toThrow( + /users\.id.*\(none\).*integer_eq/, + ) + }) +}) + +// Two declared properties resolving to the same DB column pass verification — +// each checks out against the real column — and only blow up later, inside +// `EncryptedTable.build()`, with an error from the eql/v3 layer that names +// neither the colliding properties nor the `schemas` entry they came from. +describe('duplicate declared DB names', () => { + it('throws naming the table and both colliding properties', () => { + const users = encryptedTable('users', { + a: types.TextSearch('email'), + b: types.TextSearch('email'), + }) + expect(() => verifyDeclaredSchemas({ users }, introspection)).toThrow( + /users.*email.*"a".*"b"|users.*"a".*"b".*email/, + ) + }) + + it('allows two properties on different DB columns', () => { + const users = encryptedTable('users', { + a: types.TextSearch('email'), + b: types.IntegerOrd('amount'), + }) + expect(() => verifyDeclaredSchemas({ users }, introspection)).not.toThrow() + }) +}) diff --git a/packages/stack/__tests__/supabase.test.ts b/packages/stack-supabase/__tests__/supabase.test.ts similarity index 98% rename from packages/stack/__tests__/supabase.test.ts rename to packages/stack-supabase/__tests__/supabase.test.ts index 175c90604..1023bc387 100644 --- a/packages/stack/__tests__/supabase.test.ts +++ b/packages/stack-supabase/__tests__/supabase.test.ts @@ -1,11 +1,11 @@ import 'dotenv/config' +import { Encryption } from '@cipherstash/stack' +import { encryptedColumn, encryptedTable } from '@cipherstash/stack/schema' import { createClient } from '@supabase/supabase-js' import postgres from 'postgres' import { afterAll, beforeAll, describe, expect, it } from 'vitest' -import { Encryption } from '@/index' -import { encryptedColumn, encryptedTable } from '@/schema' -import { encryptedSupabase } from '@/supabase' +import { encryptedSupabase } from '../src/index.js' // supabase.test.ts needs a live Supabase project, so the suite is skipped // when the Supabase environment is not configured (e.g. in CI, pending a diff --git a/packages/stack-supabase/integration/adapter.ts b/packages/stack-supabase/integration/adapter.ts new file mode 100644 index 000000000..e8e1c68fc --- /dev/null +++ b/packages/stack-supabase/integration/adapter.ts @@ -0,0 +1,231 @@ +import { encryptedTable } from '@cipherstash/stack/eql/v3' +import { + databaseUrl, + type IntegrationAdapter, + type PlainRow, + type QueryOp, + type QueryOpKind, + type TableSpec, +} from '@cipherstash/test-kit' +import postgres from 'postgres' +import { encryptedSupabaseV3 } from '../src/index.js' +import { makePostgrestClient, reloadSchemaCache } from './helpers/pgrest' + +/** + * The Supabase v3 adapter under real ZeroKMS ciphertext. + * + * Built through the PUBLIC `encryptedSupabaseV3` factory, so the shipped + * construction path runs: introspection over `pg`, declared-schema verification + * against the live domains, and a real `Encryption({ eqlVersion: 3 })` client. + * A hand-assembled builder would skip all three. + * + * The table therefore has to exist before the instance is constructed — + * introspection reads it — which is why `createTable` also builds the client. + */ + +/** + * `order` is supported. The builder rewrites an encrypted ordering column to the + * jsonb path `col->op`, which selects the OPE term; OPE is order-preserving, so + * PostgREST reproduces the plaintext order. Columns with no ordering term are + * rejected by the capability matrix, exactly like `gt`/`lt`. + */ +const SUPPORTED_OPS: ReadonlySet = new Set([ + 'eq', + 'ne', + 'in', + 'notIn', + 'gt', + 'gte', + 'lt', + 'lte', + 'between', + 'notBetween', + 'matches', + 'isNull', + 'isNotNull', + 'order', +]) + +/** + * Nothing is refused adapter-wide. ORE-backed columns cannot be ordered through + * PostgREST, but they are `deferred` in the catalog — they cannot hold data on + * managed Postgres at all — so no test reaches them here. + */ +const ALWAYS_REJECTED: ReadonlySet = new Set() + +type Instance = Awaited> + +// biome-ignore lint/suspicious/noExplicitAny: the builder is generic over a row type the driver does not know +type Query = any + +export function makeSupabaseAdapter(): IntegrationAdapter { + let sql: postgres.Sql + let instance: Instance + let tableName: string + + const from = (): Query => instance.from(tableName) + + /** Apply `op` to a `select('row_key')` query. May throw synchronously — the + * capability and ordering guards fire at call time, not on execute. */ + const applyOp = (op: QueryOp): Query => { + const q = from().select('row_key') + switch (op.kind) { + case 'eq': + return q.eq(op.column, op.value) + case 'ne': + return q.neq(op.column, op.value) + case 'gt': + return q.gt(op.column, op.value) + case 'gte': + return q.gte(op.column, op.value) + case 'lt': + return q.lt(op.column, op.value) + case 'lte': + return q.lte(op.column, op.value) + case 'in': + // Two distinct code paths: `.in()` and the raw `.filter(col, 'in', […])`. + // The raw one encrypted the whole list as a single term until recently, + // so both must be proven against the same oracle. + return op.asRawFilter + ? q.filter(op.column, 'in', [...op.values]) + : q.in(op.column, [...op.values]) + case 'notIn': + return q.not(op.column, 'in', [...op.values]) + case 'between': + // The builder exposes no `between`; it is `gte AND lte` by definition. + return q.gte(op.column, op.lo).lte(op.column, op.hi) + case 'notBetween': + // Structured `.or()`, not an or-STRING: a string operand would have to + // stringify Dates and bigints, and the parser would then have to guess + // them back. The structured form carries the plaintext through intact. + return q.or([ + { column: op.column, op: 'lt', value: op.lo }, + { column: op.column, op: 'gt', value: op.hi }, + ]) + case 'matches': + return q.matches(op.column, op.needle) + case 'isNull': + return q.is(op.column, null) + case 'isNotNull': + return q.not(op.column, 'is', null) + case 'order': + // Exclude the all-NULL row: NULL ordering is a property of the SQL + // dialect, not of the encrypted ordering term, and the oracle sorts + // value rows only. + // + // The secondary sort on `row_key` is load-bearing. A domain with fewer + // distinct samples than rows gives two rows the SAME plaintext, so the + // encrypted term alone does not determine their order — the oracle + // breaks such ties on `row_key` ascending, and the query must mirror it + // or the test flakes rather than proving ordering. (date/timestamp have + // two samples across three rows; the numeric families have four.) + return q + .not(op.column, 'is', null) + .order(op.column, { ascending: op.direction === 'asc' }) + .order('row_key', { ascending: true }) + } + } + + return { + name: 'supabase', + supportedOps: SUPPORTED_OPS, + alwaysRejectedOps: ALWAYS_REJECTED, + // `.in()` and the raw `.filter(col, 'in', […])` are different code paths. + hasRawInListPath: true, + + async setup() { + sql = postgres(databaseUrl(), { prepare: false }) + }, + + async teardown() { + if (tableName) await sql.unsafe(`DROP TABLE IF EXISTS ${tableName}`) + await sql.end() + }, + + async createTable(table: TableSpec) { + tableName = table.name + + const columns = table.columns + .map((column) => `"${column.slug}" ${column.eqlType}`) + .join(',\n ') + + await sql.unsafe(`DROP TABLE IF EXISTS ${table.name}`) + await sql.unsafe(` + CREATE TABLE ${table.name} ( + row_key TEXT PRIMARY KEY, + ${columns} + ) + `) + // The EQL grants cover `eql_v3` objects, not application tables. PostgREST + // runs as `anon`; without this every query is a 401. + await sql.unsafe( + `GRANT SELECT, INSERT, UPDATE, DELETE ON ${table.name} TO anon, authenticated`, + ) + await reloadSchemaCache(sql, table.name) + + const schema = encryptedTable( + table.name, + Object.fromEntries( + table.columns.map((column) => [ + column.slug, + column.spec.builder(column.slug), + ]), + ) as never, + ) + + // `schemas` is a Record keyed by table name, not an array — the factory + // rejects a key that disagrees with the table's own name. + instance = await encryptedSupabaseV3(makePostgrestClient(), { + schemas: { [table.name]: schema } as never, + databaseUrl: databaseUrl(), + }) + }, + + async insertSingle(_table: TableSpec, row: PlainRow) { + // A single object routes through `encryptModel`; an array routes through + // `bulkEncryptModels`. Both must be exercised. + const { error } = await from().insert({ + row_key: row.rowKey, + ...row.values, + }) + if (error) + throw new Error(`insertSingle(${row.rowKey}): ${error.message}`) + }, + + async insertBulk(_table: TableSpec, rows: readonly PlainRow[]) { + const models = rows.map((row) => ({ row_key: row.rowKey, ...row.values })) + const { error } = await from().insert(models) + if (error) throw new Error(`insertBulk: ${error.message}`) + }, + + async run(_table: TableSpec, op: QueryOp): Promise { + const { data, error } = await applyOp(op) + if (error) throw new Error(`${op.kind}(${op.column}): ${error.message}`) + return (data as { row_key: string }[]).map((row) => row.row_key) + }, + + async expectRejected(_table: TableSpec, op: QueryOp) { + // The rejection fires in one of two places: a capability check throws + // synchronously while collecting terms (marked `[supabase v3]`), or a term + // that reaches `execute` comes back as a Result error. Accept either — but + // NOT an arbitrary throw. A `TypeError` while assembling the term, or a + // network failure, is not the refusal this test asserts; counting it would + // let the test pass for the wrong reason if the real capability guard were + // removed. The `try` wraps only `applyOp`, and the "not rejected" error is + // thrown OUTSIDE it, so it can never be swallowed as a rejection. + let error: { message: string } | null + try { + ;({ error } = await applyOp(op)) + } catch (cause) { + if (cause instanceof Error && cause.message.includes('[supabase v3]')) { + return // a modeled capability rejection + } + throw cause // an unexpected error — fail loudly + } + if (error) return // an execute-time DB refusal (e.g. a PostgREST error) + throw new Error( + `Expected ${op.kind}("${op.column}") to be rejected, but it succeeded`, + ) + }, + } +} diff --git a/packages/stack-supabase/integration/families.integration.test.ts b/packages/stack-supabase/integration/families.integration.test.ts new file mode 100644 index 000000000..b7329b36c --- /dev/null +++ b/packages/stack-supabase/integration/families.integration.test.ts @@ -0,0 +1,21 @@ +import { FAMILY_NAMES } from '@cipherstash/test-kit' +import { runFamilySuite } from '@cipherstash/test-kit/suite' +import { makeSupabaseAdapter } from './adapter' + +/** + * Every EQL v3 domain the SDK models, driven through the Supabase adapter + * against real ZeroKMS ciphertext. + * + * One file, not one per family. The driver derives the whole suite from the + * catalog, so a per-family file was three identical lines and bought nothing: + * `fileParallelism` is off (one database, shared tables), and vitest names each + * failure by its `describe` path — `v3 supabase — text > text_match > …` — so a + * failing family is just as identifiable from here. + * + * Iterating `FAMILY_NAMES` also closes a gap a hand-written file list cannot: a + * new family added to the kit is covered without touching this file, and a + * family removed from the kit cannot leave an orphaned suite behind. + */ +for (const family of FAMILY_NAMES) { + runFamilySuite(family, makeSupabaseAdapter) +} diff --git a/packages/stack-supabase/integration/grants.integration.test.ts b/packages/stack-supabase/integration/grants.integration.test.ts new file mode 100644 index 000000000..43bfa13e0 --- /dev/null +++ b/packages/stack-supabase/integration/grants.integration.test.ts @@ -0,0 +1,174 @@ +/** + * Live proof that the shipped Supabase v3 grants let `anon` actually run the + * queries the v3 adapter emits. + * + * ## What went wrong + * `supabasePermissionsSql` granted exactly one schema, `eql_v3`. But the public + * entry points the query path calls — `eql_v3.eq_term`, `ord_term`, + * `match_term` — are SECURITY INVOKER and qualify `eql_v3_internal.*` by name in + * their bodies. Postgres resolves those names with the CALLER's privileges and + * checks schema USAGE at name resolution, so `anon` got + * `permission denied for schema eql_v3_internal` on EVERY encrypted filter: + * `=` (eq_term), `>=` (ord_term) and `@>`/`cs` (match_term) alike. + * + * `packages/stack/__tests__/supabase-v3-builder.test.ts` cannot see this — it + * records wire strings against a mock. Only a real Postgres can. + * + * ## Why the grants SQL is imported from `stash` + * Via `../../cli/src/installer/grants` — an import-free module — rather than a + * package dependency: `stash` already depends on `@cipherstash/stack`, so a + * dependency the other way would be a cycle. Asserting against the EXACT string + * the CLI installs (and embeds into the generated Supabase migration) is the + * whole point; a local copy would drift and this suite would prove nothing. + * + * ## Why no CipherStash credentials + * The probe never needs ciphertext. `eql_v3_internal.ore_block_256('{}')` fails + * on DATA for a caller that can resolve the schema, and on PERMISSION for one + * that cannot. Those two errors are what separate a working `anon` from a + * broken one, and neither requires a valid envelope — so this runs on the + * `DATABASE_URL`-only gate, alongside `supabase-v3-introspect-pg`. + */ + +import { databaseUrl } from '@cipherstash/test-kit' +import postgres from 'postgres' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { + SUPABASE_PERMISSIONS_SQL_V3, + supabaseInternalPermissionsSql, +} from '../../cli/src/installer/grants' + +const sql = postgres(databaseUrl(), { prepare: false }) + +const INTERNAL_SCHEMA = 'eql_v3_internal' + +/** The roles `SUPABASE_PERMISSIONS_SQL_V3` names. `postgres` is named too, by + * the `ALTER DEFAULT PRIVILEGES FOR ROLE postgres` lines — a plain Postgres + * image has none of them. */ +const REQUIRED_ROLES = ['postgres', 'anon', 'authenticated', 'service_role'] + +/** + * The probe: resolvable-but-invalid input. + * + * - caller CAN reach the schema → PL/pgSQL raises `Expected an ore index (ob)…` + * - caller CANNOT → the parser raises `permission denied for schema` + * + * The distinction is the entire test, and it needs no encryption client. + */ +const PROBE = `SELECT ${INTERNAL_SCHEMA}.ore_block_256('{}'::jsonb)` +const DATA_ERROR = /Expected an ore index/i +const PERMISSION_ERROR = /permission denied for schema eql_v3_internal/i + +/** Run `PROBE` as `anon`, returning the error message Postgres raised. */ +async function probeAsAnon(): Promise { + const reserved = await sql.reserve() + try { + await reserved.unsafe('SET ROLE anon') + await reserved.unsafe(PROBE) + return '' + } catch (error) { + return (error as Error).message + } finally { + await reserved.unsafe('RESET ROLE').catch(() => {}) + reserved.release() + } +} + +beforeAll(async () => { + // EQL v3 (and its `--supabase` grants) is installed once per run by + // `global-setup.ts`; this suite then revokes and re-applies the grant SQL in + // isolation to prove that SQL, so it needs the schema to already exist. + + // `CREATE ROLE IF NOT EXISTS` does not exist; a shared CI database may + // already carry these from an earlier run. + for (const role of REQUIRED_ROLES) { + await sql.unsafe(` + DO $$ BEGIN + IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${role}') THEN + CREATE ROLE ${role} NOLOGIN; + END IF; + END $$; + `) + } + + // Start from no internal-schema access. GRANTs persist in the database, so on + // a reused local database (or a rerun) the roles would still carry USAGE from + // the previous run and this suite would pass without the SQL under test ever + // granting anything. Revoking first makes the assertions depend on + // `SUPABASE_PERMISSIONS_SQL_V3` rather than on accumulated state. Only these + // three roles are touched; the owner every other live suite connects as is + // unaffected. + await sql.unsafe( + `REVOKE ALL ON SCHEMA ${INTERNAL_SCHEMA} FROM anon, authenticated, service_role`, + ) + + // The SQL under test, executed exactly as the CLI installer executes it: + // one multi-statement string. + await sql.unsafe(SUPABASE_PERMISSIONS_SQL_V3) +}, 120_000) + +afterAll(async () => { + await sql.end() +}) + +describe('supabase v3 grants against real Postgres', () => { + it('grants anon USAGE on eql_v3_internal', async () => { + const [row] = await sql<{ usage: boolean }[]>` + SELECT has_schema_privilege('anon', ${INTERNAL_SCHEMA}, 'USAGE') AS usage + ` + expect(row.usage).toBe(true) + }) + + // The regression itself. Before the fix this raised + // "permission denied for schema eql_v3_internal". + it('lets anon resolve the internal schema the term extractors reach into', async () => { + const message = await probeAsAnon() + + expect(message).not.toMatch(PERMISSION_ERROR) + expect(message).toMatch(DATA_ERROR) + }) + + // Proves the assertion above is not vacuous: strip ONLY the internal-schema + // grants and anon breaks; re-apply them and it recovers. Without this, a + // future change that made `ore_block_256` fail early — or that dropped the + // internal grants while some other GRANT happened to cover them — would leave + // the test above passing for the wrong reason. + it('breaks anon when the internal-schema grants are removed', async () => { + await sql.unsafe(`REVOKE ALL ON SCHEMA ${INTERNAL_SCHEMA} FROM anon`) + try { + expect(await probeAsAnon()).toMatch(PERMISSION_ERROR) + } finally { + await sql.unsafe(supabaseInternalPermissionsSql(INTERNAL_SCHEMA)) + } + + expect(await probeAsAnon()).toMatch(DATA_ERROR) + }) + + // WHY the grant is needed. If EQL upstream ever makes these SECURITY DEFINER, + // or stops qualifying the internal schema, the grant becomes unnecessary and + // this suite should be revisited rather than silently kept alive. + it('term extractors are SECURITY INVOKER and qualify eql_v3_internal', async () => { + const rows = await sql< + { proname: string; total: bigint; qualifies: bigint; invoker: boolean }[] + >` + SELECT p.proname, + count(*) AS total, + count(*) FILTER (WHERE p.prosrc LIKE '%eql_v3_internal.%') AS qualifies, + bool_and(NOT p.prosecdef) AS invoker + FROM pg_proc p + JOIN pg_namespace n ON n.oid = p.pronamespace + WHERE n.nspname = 'eql_v3' + AND p.proname IN ('eq_term', 'ord_term', 'match_term') + GROUP BY p.proname + ` + + expect(rows.map((r) => r.proname).sort()).toEqual([ + 'eq_term', + 'match_term', + 'ord_term', + ]) + for (const row of rows) { + expect(row.invoker).toBe(true) + expect(Number(row.qualifies)).toBeGreaterThan(0) + } + }) +}) diff --git a/packages/stack-supabase/integration/helpers/pgrest.ts b/packages/stack-supabase/integration/helpers/pgrest.ts new file mode 100644 index 000000000..dfd59799f --- /dev/null +++ b/packages/stack-supabase/integration/helpers/pgrest.ts @@ -0,0 +1,75 @@ +/** + * A real PostgREST in front of a real Postgres, for the live supabase v3 suite. + * + * `SupabaseClientLike` is just `{ from(table): … }` (`src/supabase/types.ts`), so + * a bare `PostgrestClient` satisfies the adapter with no anon key, no JWT, and + * none of the Supabase auth stack. What it does give us is the one thing the + * mock cannot: PostgREST actually parsing `prop:db_name::jsonb` aliasing selects + * against a DOMAIN column, mapping `cs` to `@>`, re-parsing a double-quoted JSON + * envelope inside `or=(…)`, and coercing a full storage envelope through the + * `public.*` domain CHECK on every filter operand. + */ + +import { PostgrestClient } from '@supabase/postgrest-js' +import type postgres from 'postgres' +import type { SupabaseClientLike } from '../../src/types' + +export function makePostgrestClient(): SupabaseClientLike { + const url = process.env.PGRST_URL + if (!url) { + throw new Error( + 'PGRST_URL is not set. The integration `globalSetup` asserts it before any ' + + 'suite is collected, so reaching this means makePostgrestClient() was ' + + 'called outside the integration harness.', + ) + } + return new PostgrestClient(url) as unknown as SupabaseClientLike +} + +/** + * Ask PostgREST to reload its schema cache, then WAIT until it really has. + * + * PostgREST caches the schema at boot, and this suite creates its table in + * `beforeAll`, long after that. Getting this wrong is subtle, so: + * + * DO NOT poll with a GET against the new table. PostgREST 12 self-heals a + * cache miss by scheduling a reload and retrying THAT request, so the GET + * starts succeeding while the cache reload is still in flight. A `POST` issued + * in the window between then 404s — observed exactly this, cold: the probe GET + * returned 200, the very next insert returned 404, and a later GET returned + * 200 again. Polling reads therefore proves nothing about writes. + * + * Poll the ROOT endpoint instead. Its OpenAPI output is rendered FROM the + * loaded schema cache, so a table appearing under `paths` means the reload has + * actually landed and every verb will see it. + * + * `NOTIFY` needs `PGRST_DB_CHANNEL_ENABLED=true`; the self-heal covers us if it + * is off, but slowly and only for reads — hence both. + */ +export async function reloadSchemaCache( + sql: postgres.Sql, + tableName: string, + { timeoutMs = 30_000, intervalMs = 100 } = {}, +): Promise { + await sql.unsafe(`NOTIFY pgrst, 'reload schema'`) + + const url = process.env.PGRST_URL + const deadline = Date.now() + timeoutMs + let lastStatus = 0 + + while (Date.now() < deadline) { + const response = await fetch(`${url}/`) + lastStatus = response.status + if (response.ok) { + const spec = (await response.json()) as { + paths?: Record + } + if (spec.paths && Object.hasOwn(spec.paths, `/${tableName}`)) return + } + await new Promise((resolve) => setTimeout(resolve, intervalMs)) + } + + throw new Error( + `PostgREST never loaded table "${tableName}" into its schema cache within ${timeoutMs}ms (last root status: ${lastStatus}). Is PGRST_DB_CHANNEL_ENABLED=true, and does the anon role have SELECT on the table?`, + ) +} diff --git a/packages/stack-supabase/integration/helpers/v3-envelope.ts b/packages/stack-supabase/integration/helpers/v3-envelope.ts new file mode 100644 index 000000000..31c89a15c --- /dev/null +++ b/packages/stack-supabase/integration/helpers/v3-envelope.ts @@ -0,0 +1,104 @@ +/** + * Structurally-valid EQL v3 storage envelopes, built without a CipherStash client. + * + * The `public.*` domain CHECKs are purely STRUCTURAL — e.g. `public.eql_v3_text_search` + * requires an object with `v`/`i`/`c`/`hm`/`op`/`bf` and `v = '3'`. Nothing in + * the CHECK is cryptographic. That lets the live + * PostgREST suite drive the real adapter against real domains and real + * `eql_v3` operators with no ZeroKMS round-trip, so it runs wherever + * `DATABASE_URL` runs. + * + * What this CAN prove: the wire encoding PostgREST accepts, that a full storage + * envelope clears the domain CHECK on every filter operand while a narrowed + * `encryptQuery` term does not, that `cs` resolves to bloom containment, and + * that the Supabase roles hold the grants those operators need. + * + * What it CANNOT prove: that ciphertext decrypts, or that ORE ordering is + * semantically correct. `drizzle-v3/operators-live-pg.test.ts` covers those with + * real credentials. + */ + +/** `hm` — the HMAC equality term. Any stable string; equality is by identity. */ +function hmacFor(value: string): string { + return `hm-${value}` +} + +/** + * `ob` — one ORE block-256 term. + * + * `eql_v3_internal.compare_ore_block_256_term` derives the block count from the + * ciphertext length and rejects anything else: the layout is + * `[N PRP bytes][N*16B left][16B hash key][N*32B right]`, so + * `octet_length = 49*N + 16`. N=1 → 65 bytes. A shorter term raises + * "Malformed ORE term: bytes" from inside the operator, which is a far more + * confusing failure than a CHECK violation. + * + * Comparisons between two such terms EXECUTE but carry no order semantics — a + * term only reliably compares equal to itself. Suites must not assert `<`/`>` + * outcomes on synthetic terms. + */ +const ORE_TERM_BYTES = 49 * 1 + 16 + +function oreTermFor(seed: number): string { + const byte = (seed % 251).toString(16).padStart(2, '0') + return byte.repeat(ORE_TERM_BYTES) +} + +/** + * `op` — the CLLW-OPE term (eql-3.0.0 `_ord` / `text_search` domains): a + * hex-encoded bytea, compared byte-wise. Any even-length hex string clears the + * structural CHECK; identical seeds compare equal, which is all the suites + * rely on (no `<`/`>` semantics on synthetic terms). + */ +function opeTermFor(seed: number): string { + const byte = (seed % 251).toString(16).padStart(2, '0') + return byte.repeat(16) +} + +/** `bf` — the bloom filter for match/`cs`. A set of token positions. */ +function bloomFor(tokens: number[]): number[] { + return [...new Set(tokens)].sort((a, b) => a - b) +} + +export type EnvelopeParts = { + table: string + column: string + /** Distinguishes ciphertexts; also seeds the ORE term. */ + seed: number + /** Present on equality-capable domains (`hm`). */ + hmac?: string + /** Present on block-ORE order domains — `_ord_ore` (`ob`). */ + ore?: boolean + /** Present on CLLW-OPE order domains — `_ord`, `text_search` (`op`). */ + ope?: boolean + /** Present on match-capable domains (`bf`). */ + bloom?: number[] +} + +/** A full STORAGE envelope — what `encrypt()` returns and every filter operand + * must be. Includes `c`, which a narrowed `encryptQuery` term omits. */ +export function storageEnvelope(parts: EnvelopeParts): Record { + const envelope: Record = { + v: '3', + i: { t: parts.table, c: parts.column }, + c: `ct-${parts.column}-${parts.seed}`, + } + if (parts.hmac !== undefined) envelope.hm = hmacFor(parts.hmac) + if (parts.ore) envelope.ob = [oreTermFor(parts.seed)] + if (parts.ope) envelope.op = opeTermFor(parts.seed) + if (parts.bloom) envelope.bf = bloomFor(parts.bloom) + return envelope +} + +/** + * The narrowed query term the v2 dialect emits (`encryptQuery`): index terms + * but NO `c`. The v3 domain CHECK requires `c`, so Postgres rejects this with + * 23514 for EVERY domain — the reason `query-builder-v3.ts` sends full + * envelopes as filter operands. The live suite asserts exactly that. + */ +export function narrowedQueryTerm( + parts: EnvelopeParts, +): Record { + const { c: _dropped, ...rest } = storageEnvelope(parts) + return rest +} diff --git a/packages/stack-supabase/integration/introspect.integration.test.ts b/packages/stack-supabase/integration/introspect.integration.test.ts new file mode 100644 index 000000000..b5b81b3ff --- /dev/null +++ b/packages/stack-supabase/integration/introspect.integration.test.ts @@ -0,0 +1,141 @@ +import { factoryForDomain } from '@cipherstash/stack/adapter-kit' +import { databaseUrl } from '@cipherstash/test-kit' +import postgres from 'postgres' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { introspect } from '../src/introspect' +import { synthesizeTables } from '../src/schema-builder' + +const sql = postgres(databaseUrl(), { prepare: false }) + +const MODELLED = 'protect_ci_v3_introspect' +const UNMODELLED = 'protect_ci_v3_unmodelled' +const USER_DOMAIN = 'protect_ci_v3_user_json' + +beforeAll(async () => { + // EQL v3 is installed once per run by `global-setup.ts`. + await sql.unsafe(`DROP TABLE IF EXISTS ${MODELLED}`) + await sql.unsafe(`DROP TABLE IF EXISTS ${UNMODELLED}`) + await sql.unsafe(` + CREATE TABLE ${MODELLED} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + email public.eql_v3_text_search NOT NULL, + amount public.eql_v3_integer_ord NOT NULL, + note TEXT, + meta jsonb + ) + `) + // A user's OWN jsonb domain, with no EQL comment. It must never be reported + // as unmodelled — it is an ordinary plaintext passthrough. + await sql.unsafe(`DROP DOMAIN IF EXISTS public.${USER_DOMAIN}`) + await sql.unsafe(`CREATE DOMAIN public.${USER_DOMAIN} AS jsonb`) + // This table exercises all three cases the introspector must tell apart: + // score → EQL domain (eql_v3_integer_ord_ope) the SDK has no factory for + // → "unmodelled", MUST be reported so the caller knows it can't query it + // doc → EQL domain (eql_v3_json) the SDK models via types.Json + // → modelled, MUST be synthesized and NOT reported + // own → a user's own plain jsonb domain with no EQL marker + // → plaintext passthrough, MUST never be reported + await sql.unsafe(` + CREATE TABLE ${UNMODELLED} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + score public.eql_v3_integer_ord_ope NOT NULL, + doc public.eql_v3_json, + own public.${USER_DOMAIN} + ) + `) +}, 30000) + +afterAll(async () => { + await sql.unsafe(`DROP TABLE IF EXISTS ${MODELLED}`) + await sql.unsafe(`DROP TABLE IF EXISTS ${UNMODELLED}`) + await sql.unsafe(`DROP DOMAIN IF EXISTS public.${USER_DOMAIN}`) + await sql.end() +}, 30000) + +describe('eql_v3 supabase introspection', () => { + it('detects EQL v3 domains and classifies plaintext columns', async () => { + const { tables } = await introspect(databaseUrl()) + const table = tables.find((t) => t.tableName === MODELLED) + expect(table).toBeDefined() + const domains = Object.fromEntries( + table!.columns.map((c) => [c.columnName, c.domainName]), + ) + expect(domains.email).toBe('eql_v3_text_search') + expect(domains.amount).toBe('eql_v3_integer_ord') + // Plaintext + plain jsonb → NULL (udt_name is jsonb for all of these). + expect(domains.id).toBeNull() + expect(domains.note).toBeNull() + expect(domains.meta).toBeNull() + }, 30000) + + it('round-trips the domain → builder mapping via synthesizeTables', async () => { + const { tables } = await introspect(databaseUrl()) + + const { tables: synth, allColumns } = synthesizeTables(tables) + const table = synth.get(MODELLED) + expect(Object.keys(table!.columnBuilders).sort()).toEqual([ + 'amount', + 'email', + ]) + expect(table!.columnBuilders.email.getEqlType()).toBe( + 'public.eql_v3_text_search', + ) + expect(table!.columnBuilders.amount.getEqlType()).toBe( + 'public.eql_v3_integer_ord', + ) + expect(allColumns.get(MODELLED)).toEqual([ + 'id', + 'email', + 'amount', + 'note', + 'meta', + ]) + }, 30000) + + // The three-way classification now lives entirely in the SQL predicate of + // `UNMODELLED_COLUMNS_QUERY`: EQL-by-COMMENT, and not in `DOMAIN_REGISTRY`. + // These prove it against a real catalog — nothing else does. + it('reports unmodelled EQL columns, keyed by table', async () => { + const { unmodelled } = await introspect(databaseUrl()) + + // Sanity, keyed exactly as the registry keys and the introspection query do + // (the full `eql_v3_*` domain name): `eql_v3_integer_ord_ope` has no types + // factory (unmodelled → reported), whereas `eql_v3_json` now HAS one + // (`types.Json` → modelled → NOT reported). + expect(factoryForDomain('eql_v3_integer_ord_ope')).toBeUndefined() + expect(factoryForDomain('eql_v3_json')).toBeDefined() + + const offenders = unmodelled.get(UNMODELLED) + expect(offenders).toBeDefined() + expect(offenders?.map((c) => c.columnName).sort()).toEqual(['score']) + expect(offenders?.find((c) => c.columnName === 'score')?.domainName).toBe( + 'eql_v3_integer_ord_ope', + ) + }, 30000) + + it('does not report a fully-modelled table', async () => { + const { unmodelled } = await introspect(databaseUrl()) + expect(unmodelled.has(MODELLED)).toBe(false) + }, 30000) + + it("does not report a user's own jsonb domain as unmodelled", async () => { + const { unmodelled } = await introspect(databaseUrl()) + // `own` carries a public domain with NO EQL comment → plaintext, not a leak. + const offenders = unmodelled.get(UNMODELLED) ?? [] + expect(offenders.map((c) => c.columnName)).not.toContain('own') + }, 30000) + + // The precondition that makes the `from()` guard load-bearing: an unmodelled + // column is silently dropped from the encrypt config, yet stays in + // `allColumns` — so `select('*')` would select it and return raw ciphertext. + // `doc` (modelled json) gets a builder; `score` (unmodelled) is dropped from + // the config but retained in `allColumns`. + it('synthesizeTables drops an unmodelled column but allColumns keeps it', async () => { + const { tables } = await introspect(databaseUrl()) + const { tables: synth, allColumns } = synthesizeTables(tables) + + expect(Object.keys(synth.get(UNMODELLED)!.columnBuilders)).toEqual(['doc']) + expect(allColumns.get(UNMODELLED)).toContain('score') + expect(allColumns.get(UNMODELLED)).toContain('doc') + }, 30000) +}) diff --git a/packages/stack-supabase/integration/select-alias.integration.test.ts b/packages/stack-supabase/integration/select-alias.integration.test.ts new file mode 100644 index 000000000..0e62523a3 --- /dev/null +++ b/packages/stack-supabase/integration/select-alias.integration.test.ts @@ -0,0 +1,125 @@ +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { databaseUrl } from '@cipherstash/test-kit' +import postgres from 'postgres' +import { afterAll, beforeAll, expect, it } from 'vitest' +import { encryptedSupabaseV3 } from '../src/index.js' +import { makePostgrestClient, reloadSchemaCache } from './helpers/pgrest' + +/** + * `Date` reconstruction across every way PostgREST can key a result row. + * + * Not expressible through the family driver: it is about the SELECT string, not + * about a query operation, and only the Supabase adapter has the concept. The + * driver proves the operations; this proves the projection. + * + * A decrypted date-like column arrives as an ISO string, and the adapter rebuilds + * the `Date` by looking up the column's `cast_as`. That lookup is keyed by DB + * column name, so it needs a map from the ROW KEY back to the DB column — and the + * row key is whatever PostgREST chose, which is one of three things: + * + * .select('createdAt') -> keyed `createdAt` (the JS property; renamed) + * .select('created_at') -> keyed `created_at` (the raw DB name) + * .select('ts:createdAt') -> keyed `ts` (a caller-chosen alias) + * + * The third case regressed: `selectKeyToDb` was dropped from `buildSelectString`, + * so an aliased date column came back as a string where the typed surface + * promises a `Date`. + */ +const TABLE = `v3_it_alias_${Math.random().toString(36).slice(2, 8)}` +const CREATED = new Date('2026-01-02T03:04:05.000Z') + +// `createdAt` -> `created_at` is the rename the aliasing `prop:db_name::jsonb` +// select exists for; a table whose property equals its DB name cannot express it. +const rows = encryptedTable(TABLE, { + createdAt: types.Timestamp('created_at'), + bornOn: types.Date('born_on'), +}) + +const sql = postgres(databaseUrl(), { prepare: false }) +// biome-ignore lint/suspicious/noExplicitAny: the row type varies per select +let instance: any + +beforeAll(async () => { + await sql.unsafe(`DROP TABLE IF EXISTS ${TABLE}`) + await sql.unsafe(` + CREATE TABLE ${TABLE} ( + row_key TEXT PRIMARY KEY, + created_at public.eql_v3_timestamp, + born_on public.eql_v3_date + ) + `) + await sql.unsafe( + `GRANT SELECT, INSERT, UPDATE, DELETE ON ${TABLE} TO anon, authenticated`, + ) + await reloadSchemaCache(sql, TABLE) + + instance = await encryptedSupabaseV3(makePostgrestClient(), { + schemas: { [TABLE]: rows } as never, + databaseUrl: databaseUrl(), + }) + + const { error } = await instance + .from(TABLE) + .insert({ row_key: 'a', createdAt: CREATED, bornOn: CREATED }) + if (error) throw new Error(`insert: ${error.message}`) +}, 300_000) + +afterAll(async () => { + await sql.unsafe(`DROP TABLE IF EXISTS ${TABLE}`) + await sql.end() +}) + +it('reconstructs a Date keyed by the JS property name', async () => { + const { data, error } = await instance + .from(TABLE) + .select('row_key, createdAt') + + expect(error).toBeNull() + expect(data[0].createdAt).toBeInstanceOf(Date) + expect((data[0].createdAt as Date).toISOString()).toBe(CREATED.toISOString()) +}) + +it('reconstructs a Date keyed by the raw DB column name', async () => { + const { data, error } = await instance + .from(TABLE) + .select('row_key, created_at') + + expect(error).toBeNull() + expect(data[0].created_at).toBeInstanceOf(Date) +}) + +it('reconstructs a Date keyed by a caller-chosen alias', async () => { + const { data, error } = await instance + .from(TABLE) + .select('row_key, ts:createdAt') + + expect(error).toBeNull() + expect(data[0].ts).toBeInstanceOf(Date) + expect((data[0].ts as Date).toISOString()).toBe(CREATED.toISOString()) +}) + +it('reconstructs a Date under an alias of the raw DB column name', async () => { + const { data, error } = await instance + .from(TABLE) + .select('row_key, at:created_at') + + expect(error).toBeNull() + expect(data[0].at).toBeInstanceOf(Date) +}) + +// `date` and `timestamp` are separate `cast_as` values; both are date-like, and +// both must be reconstructed under an alias. +it('reconstructs an aliased date column, not just timestamp', async () => { + const { data, error } = await instance.from(TABLE).select('row_key, d:bornOn') + + expect(error).toBeNull() + expect(data[0].d).toBeInstanceOf(Date) +}) + +it('expands select(*) with every date column reconstructed', async () => { + const { data, error } = await instance.from(TABLE).select('*') + + expect(error).toBeNull() + expect(data[0].createdAt).toBeInstanceOf(Date) + expect(data[0].bornOn).toBeInstanceOf(Date) +}) diff --git a/packages/stack-supabase/integration/vitest.config.ts b/packages/stack-supabase/integration/vitest.config.ts new file mode 100644 index 000000000..4dc30e9c2 --- /dev/null +++ b/packages/stack-supabase/integration/vitest.config.ts @@ -0,0 +1,22 @@ +import { resolve } from 'node:path' +import { defineConfig } from 'vitest/config' +import { sharedAlias, stackSourceAlias } from '../../../vitest.shared' +import { + integrationHarness, + integrationTestDefaults, +} from '../../test-kit/src/integration/config' + +/** + * Integration suites for the supabase adapter: real ZeroKMS + real Postgres + * (+ PostgREST for supabase). Runs only under `test:integration` (its own CI + * job). Harness + shared `test.*` knobs come from `@cipherstash/test-kit`. + */ +export default defineConfig({ + resolve: { alias: { ...sharedAlias, ...stackSourceAlias } }, + test: { + root: resolve(__dirname, '..'), + include: ['integration/**/*.integration.test.ts'], + ...integrationHarness, + ...integrationTestDefaults, + }, +}) diff --git a/packages/stack-supabase/integration/wire.integration.test.ts b/packages/stack-supabase/integration/wire.integration.test.ts new file mode 100644 index 000000000..dd7b92bee --- /dev/null +++ b/packages/stack-supabase/integration/wire.integration.test.ts @@ -0,0 +1,640 @@ +/** + * The supabase v3 adapter, executed against a real PostgREST and real + * `public.*` domains, as the `anon` role. + * + * Every other supabase v3 test drives `createMockSupabase` — an argument + * recorder with no SQL behind it. It can prove the adapter EMITS + * `email.cs."{…}"`; it cannot prove PostgREST parses that, that `cs` maps to + * `@>` on a domain column, that a full storage envelope clears the domain CHECK + * as a filter operand, or that `anon` holds the grants those operators need. + * Those are exactly the things that break in production, and this is the only + * suite that runs them. + * + * ## No CipherStash credentials + * The domain CHECKs are structural (`v`/`i`/`c` + the domain's index terms), + * not cryptographic, so `helpers/v3-envelope.ts` builds valid envelopes + * directly and the encryption client is a stub. The REAL parts are the adapter, + * `@supabase/postgrest-js`, PostgREST, the domains, the `eql_v3` operators and + * the Supabase grants. What is faked is ZeroKMS — and only ZeroKMS. + * + * Consequently this suite must never assert ORDER semantics: synthetic ORE + * terms compare equal to themselves and are otherwise meaningless. + * `drizzle-v3/operators-live-pg.test.ts` proves ordering with real ciphertext. + * + * ## As `anon`, not as the owner + * `PGRST_DB_ANON_ROLE=anon` and PostgREST connects as `authenticator`, a + * non-superuser member of `anon`. Pointing it at the DB owner would make every + * permission check pass vacuously. Running as `anon` is what caught + * `permission denied for schema eql_v3_internal` (see `supabase-v3-grants-pg`). + */ + +import type { EncryptionClient } from '@cipherstash/stack/encryption' +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { databaseUrl } from '@cipherstash/test-kit' +import postgres from 'postgres' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { EncryptedQueryBuilderV3Impl } from '../src/query-builder-v3' +import { makePostgrestClient, reloadSchemaCache } from './helpers/pgrest' +import { narrowedQueryTerm, storageEnvelope } from './helpers/v3-envelope' + +const TABLE = 'protect_ci_v3_pgrest' + +const sql = postgres(databaseUrl(), { prepare: false }) + +// A DECLARED table: `createdAt → created_at` is the rename the aliasing +// `prop:db_name::jsonb` select exists for, and a synthesized table (property == +// DB name) cannot express it. +const users = encryptedTable(TABLE, { + email: types.TextSearch('email'), + nickname: types.TextEq('nickname'), + amount: types.IntegerOrd('amount'), + createdAt: types.TimestampOrd('created_at'), + active: types.Boolean('active'), +}) + +/** Which index terms each DB column's domain CHECK demands. */ +const COLUMN_TERMS: Record< + string, + { hmac?: boolean; ope?: boolean; bloom?: boolean } +> = { + email: { hmac: true, ope: true, bloom: true }, // text_search — hm + op + bf + nickname: { hmac: true }, // text_eq + amount: { ope: true }, // integer_ord — op (CLLW-OPE, eql-3.0.0) + created_at: { ope: true }, // timestamp_ord + active: {}, // boolean — storage only +} + +/** + * Deterministic stand-in for protect-ffi's match tokenizer: `ngram` + * (`token_length: 3`) + `downcase`, hashed into the bloom's bit domain. + * + * TRIGRAMS ONLY, deliberately. This suite has no CipherStash credentials and + * mints its own envelopes, so this function IS the bloom oracle for both the + * seeded rows and the query needles — anything it invents, the tests below will + * dutifully confirm. It previously prepended the whole value as an extra token + * to emulate `include_original: true`, which made a substring `contains` fail + * and pinned that failure as expected behaviour. + * + * protect-ffi does no such thing: `include_original` is accepted and ignored + * (measured across 0.24 and 0.29, EQL v2 and v3 — the emitted bloom is + * trigram-only under either setting). Substring `contains` works, as + * `drizzle-v3/operators-live-pg.test.ts` proves against real ffi and real + * Postgres. + * + * A value shorter than `token_length` yields NO tokens, matching real ffi's + * empty bloom — the fail-open `matchNeedleError` exists to reject. + */ +function bloomTokens(value: string): number[] { + const hash = (s: string) => { + let h = 2166136261 + for (let i = 0; i < s.length; i++) + h = ((h ^ s.charCodeAt(i)) * 16777619) >>> 0 + return h % 2048 + } + const lower = value.toLowerCase() + const tokens: number[] = [] + for (let i = 0; i + 3 <= lower.length; i++) + tokens.push(hash(lower.slice(i, i + 3))) + return tokens +} + +function seedOf(value: unknown): number { + const s = String(value) + let h = 7 + for (let i = 0; i < s.length; i++) h = (h * 31 + s.charCodeAt(i)) >>> 0 + return h +} + +/** Plaintext is carried in `c` so the stub decrypt can undo it. Nothing in the + * domain CHECK inspects `c` beyond its presence. */ +function envelopeFor( + value: unknown, + dbColumn: string, +): Record { + const terms = COLUMN_TERMS[dbColumn] ?? {} + const pt = value instanceof Date ? value.toISOString() : value + const env = storageEnvelope({ + table: TABLE, + column: dbColumn, + seed: seedOf(pt), + hmac: terms.hmac ? String(pt) : undefined, + ope: terms.ope, + bloom: terms.bloom ? bloomTokens(String(pt)) : undefined, + }) + env.c = `ct:${JSON.stringify(pt)}` + return env +} + +function decryptValue(value: unknown): unknown { + if (value && typeof value === 'object' && 'c' in value) { + const c = (value as { c: string }).c + if (typeof c === 'string' && c.startsWith('ct:')) + return JSON.parse(c.slice(3)) + } + return value +} + +/** Chainable op, matching the real encryption client's surface. */ +function op(data: T) { + const self = { + withLockContext: () => self, + audit: () => self, + then: ( + onfulfilled?: ((value: { data: T }) => unknown) | null, + onrejected?: ((reason: unknown) => unknown) | null, + ) => Promise.resolve({ data }).then(onfulfilled, onrejected), + } + return self +} + +const PROP_TO_DB = users.buildColumnKeyMap() + +function stubEncryptionClient(): EncryptionClient { + const encryptModel = (model: Record) => { + const out: Record = { ...model } + for (const [prop, dbName] of Object.entries(PROP_TO_DB)) { + if (out[prop] != null) out[prop] = envelopeFor(out[prop], dbName) + } + return op(out) + } + const decryptModel = (model: Record) => { + const out: Record = {} + for (const [key, value] of Object.entries(model)) + out[key] = decryptValue(value) + return op(out) + } + const client = { + // The adapter passes the COLUMN BUILDER; its getName() is the DB name. + encrypt: (value: unknown, opts: { column: { getName(): string } }) => + op(envelopeFor(value, opts.column.getName())), + encryptModel, + bulkEncryptModels: (models: Record[]) => + op( + models.map((m) => { + const out: Record = { ...m } + for (const [prop, dbName] of Object.entries(PROP_TO_DB)) { + if (out[prop] != null) out[prop] = envelopeFor(out[prop], dbName) + } + return out + }), + ), + decryptModel, + bulkDecryptModels: (models: Record[]) => + op( + models.map((m) => { + const out: Record = {} + for (const [k, v] of Object.entries(m)) out[k] = decryptValue(v) + return out + }), + ), + } + return client as unknown as EncryptionClient +} + +const ALL_COLUMNS = [ + 'id', + 'row_key', + 'email', + 'nickname', + 'amount', + 'created_at', + 'active', + 'note', + 'tags', + 'meta', +] + +// biome-ignore lint/suspicious/noExplicitAny: the suite addresses columns outside the declared row type +function from(): any { + return new EncryptedQueryBuilderV3Impl( + TABLE, + users, + stubEncryptionClient(), + makePostgrestClient(), + ALL_COLUMNS, + ) +} + +const ADA_CREATED = new Date('2026-01-02T03:04:05.000Z') + +beforeAll(async () => { + // EQL v3 and the Supabase grants are installed once per run by `globalSetup`, + // which shells out to the real `stash eql install --eql-version 3 --supabase`. + // Re-applying them here would only test a hand-rolled approximation. + await sql.unsafe(`DROP TABLE IF EXISTS ${TABLE}`) + await sql.unsafe(` + CREATE TABLE ${TABLE} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + row_key TEXT NOT NULL, + email public.eql_v3_text_search, + nickname public.eql_v3_text_eq, + amount public.eql_v3_integer_ord, + created_at public.eql_v3_timestamp_ord, + active public.eql_v3_boolean, + note TEXT, + -- Plaintext passthrough columns. contains() on these is PostgREST's + -- NATIVE containment (cs, i.e. the @> Postgres declares on array and + -- jsonb), not the bloom-filter operator the encrypted domains declare. + -- Only a real server can prove the adapter emits an operand each accepts. + tags TEXT[], + meta JSONB + ) + `) + // The grants block covers eql_v3 objects, not application tables. + await sql.unsafe( + `GRANT SELECT, INSERT, UPDATE, DELETE ON ${TABLE} TO anon, authenticated`, + ) + + await reloadSchemaCache(sql, TABLE) +}, 180_000) + +afterAll(async () => { + await sql.unsafe(`DROP TABLE IF EXISTS ${TABLE}`) + await sql.end() +}) + +describe('supabase v3 adapter over real PostgREST (wire + grants)', () => { + it('inserts raw envelopes that clear every domain CHECK, as anon', async () => { + const { error, status } = await from().insert({ + row_key: 'ada', + email: 'ada@example.com', + nickname: 'ada', + amount: 42, + createdAt: ADA_CREATED, + active: true, + note: 'plain', + tags: ['vip', 'admin'], + meta: { plan: 'pro', seats: 3 }, + }) + + expect(error).toBeNull() + expect(status).toBeLessThan(300) + }) + + // The load-bearing claim in `query-builder-v3.ts`: a narrowed `encryptQuery` + // term carries no `c` and fails the CHECK with 23514 for EVERY domain, which + // is why filter operands are full storage envelopes. Sent straight to + // PostgREST — the adapter cannot produce this shape. + it('rejects a narrowed encryptQuery-shaped term with 23514', async () => { + const client = makePostgrestClient() as unknown as { + from(t: string): { + insert(body: unknown): Promise<{ error: { code?: string } | null }> + } + } + const { error } = await client.from(TABLE).insert({ + row_key: 'narrowed', + email: narrowedQueryTerm({ + table: TABLE, + column: 'email', + seed: 1, + hmac: 'x', + ope: true, + bloom: [1, 2], + }), + }) + + expect(error?.code).toBe('23514') + }) + + it('aliases the renamed column and reconstructs its Date', async () => { + const { data, error } = await from() + .select('row_key, createdAt') + .eq('row_key', 'ada') + + expect(error).toBeNull() + expect(data).toHaveLength(1) + expect(data[0].createdAt).toBeInstanceOf(Date) + expect((data[0].createdAt as Date).toISOString()).toBe( + ADA_CREATED.toISOString(), + ) + }) + + it('matches an eq() filter whose operand is a full storage envelope', async () => { + const { data, error } = await from().select('row_key').eq('nickname', 'ada') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // Executes `>=` through `eql_v3.gte` → `ord_term` → `eql_v3_internal`, which + // is the call chain the grants fix unblocked. Compares a term against itself, + // so it must match; no order semantics are asserted (synthetic ORE terms + // carry none). + it('executes a gte() range filter through the ORE operators', async () => { + const { data, error } = await from() + .select('row_key') + .gte('createdAt', ADA_CREATED) + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // `cs` → `@>` on the encrypted domain. This is the load-bearing assertion of + // the whole suite: the bundle declares + // CREATE OPERATOR @> (FUNCTION = eql_v3.contains, LEFTARG = public.eql_v3_text_search, + // RIGHTARG = jsonb) + // whose body is `match_term(a) @> match_term(b::public.eql_v3_text_search)` — a + // smallint[] containment of the two BLOOM FILTERS. It is NOT the built-in + // `jsonb @> jsonb`, which would compare whole envelopes and so could only ever + // match on an identical ciphertext. + // + // The four tests below discriminate: substrings that share no `c` with the + // stored row match, and a trigram present in no row does not. Only bloom + // containment explains both. + it('resolves matches() through cs containment for an exact value', async () => { + const { data, error } = await from() + .select('row_key') + .matches('email', 'ada@example.com') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // The needle blooms to its own trigrams — `exa,xam,amp,mpl,ple` — every one of + // which is a trigram of `ada@example.com`, so containment holds. This once + // asserted the opposite, on the strength of an `include_original` token that + // protect-ffi never emits; `bloomTokens` above no longer invents one. + it('matches a longer substring through bloom containment', async () => { + const { data, error } = await from() + .select('row_key') + .matches('email', 'example') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + it('matches a substring exactly one trigram long', async () => { + const { data, error } = await from() + .select('row_key') + .matches('email', 'ada') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // The discriminator. Every assertion above is satisfied by a `contains` that + // matches EVERYTHING — an empty needle bloom, a broken `@>`, a fail-open. A + // trigram held by no stored row must come back empty. (`drizzle-v3`'s live + // suite pins the same guarantee against real ffi with `'qqqzzz'`.) + it('does not match a trigram absent from every stored value', async () => { + const { data, error } = await from() + .select('row_key') + .matches('email', 'zzz') + + expect(error).toBeNull() + expect(data).toEqual([]) + }) + + // `like`/`ilike` on an encrypted column are a compatibility shim: they delegate + // to `matches` (fuzzy bloom token search), NOT SQL `~~` (undefined on + // public.eql_v3_text_search — 42883). Surrounding `%` are stripped, so + // `like('email', '%ada%')` searches the term `ada` and returns the same row as + // `matches('email', 'ada')`. + it('delegates like() on an encrypted column to matches (fuzzy)', async () => { + const { data, error } = await from() + .select('row_key') + .like('email', '%ada%') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // A pattern fuzzy matching cannot approximate (internal `%` / any `_`) is + // refused client-side before the round-trip. + it('rejects an unapproximable like() pattern on an encrypted column', () => { + expect(() => from().select('row_key').like('email', 'a%b')).toThrow( + /cannot honor/, + ) + expect(() => from().select('row_key').ilike('email', 'f_o')).toThrow( + /cannot honor/, + ) + }) + + // PostgREST must re-parse a double-quoted JSON envelope inside `or=(…)`. The + // envelope's own quotes and backslashes have to be escaped or the logic tree + // fails to parse with PGRST100. + it('re-parses a quoted envelope inside an or() condition', async () => { + const { data, error } = await from() + .select('row_key') + .or('nickname.eq.ada,row_key.eq.nobody') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // An `in`-list inside `or()` has never been executed against a real PostgREST. + // Each element is a separate JSON envelope, so the list is a comma-separated + // sequence of quote-dense operands nested inside `(…)` inside the or-tree — + // the densest thing this adapter emits. A mock cannot catch a PGRST100 here. + it('parses an encrypted in-list inside an or() condition', async () => { + const { data, error } = await from() + .select('row_key') + .or('nickname.in.(ada,nobody)') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // PostgREST negation: `column.not..`. The parser used to read `not` + // AS the operator, encrypt the literal string `in.(ada,nobody)` as one + // plaintext, and emit a filter that silently matched nothing. + it('parses a NEGATED encrypted in-list inside an or() condition', async () => { + const { data, error } = await from() + .select('row_key') + .or('nickname.not.in.(ada,nobody)') + + expect(error).toBeNull() + // `ada` is the only row and it IS in the list, so negation excludes it. + // Before the fix this returned `['ada']`: the bogus operand matched nothing, + // and `not` of nothing is everything. + expect(data).toEqual([]) + }) + + // --------------------------------------------------------------------------- + // Plaintext containment. `contains` is the one FilterOp that is a supabase-js + // METHOD name and not a PostgREST operator, so a structured `or()` used to + // emit `tags.contains.{…}` — PGRST100. Translating the token alone is not + // enough: `cs` takes a containment literal, so the `(a,b)` in-list form arrays + // otherwise get fails with 22P02. Both are executed here, against a real + // server, because a mock can only prove what string we emit. + // --------------------------------------------------------------------------- + + it('runs a native array containment through .contains() on a plaintext column', async () => { + const { data, error } = await from() + .select('row_key') + .contains('tags', ['vip']) + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + it('runs a native jsonb containment through .contains() on a plaintext column', async () => { + const { data, error } = await from() + .select('row_key') + .contains('meta', { plan: 'pro' }) + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + it('executes a structured or() contains on a plaintext array column', async () => { + const { data, error } = await from() + .select('row_key') + .or([{ column: 'tags', op: 'contains', value: ['vip', 'admin'] }]) + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + it('executes a structured or() contains on a plaintext jsonb column', async () => { + const { data, error } = await from() + .select('row_key') + .or([{ column: 'meta', op: 'contains', value: { plan: 'pro' } }]) + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // A containment literal's braces hold top-level commas. Naming an encrypted + // column forces the parse → rebuild path, where those commas must not be read + // as condition separators — otherwise `tags` is filtered on a truncated + // `{vip` and the whole or-tree quietly returns the wrong rows. + it('preserves a plaintext containment literal in a mixed or() string', async () => { + const { data, error } = await from() + .select('row_key') + .or('nickname.eq.nobody,tags.cs.{vip,admin}') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + it('matches nothing when the containment literal is not contained', async () => { + const { data, error } = await from() + .select('row_key') + .or([{ column: 'tags', op: 'contains', value: ['vip', 'absent'] }]) + + expect(error).toBeNull() + expect(data).toEqual([]) + }) + + it('parses a negated encrypted scalar inside an or() condition', async () => { + const { data, error } = await from() + .select('row_key') + .or('nickname.not.eq.nobody') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // `is` reaches Postgres as `is` with a bare `null` — never encrypted. This is + // the wire shape `fd33aadf` established and it had never been executed. + it('sends is.null on an encrypted column unencrypted', async () => { + const { data, error } = await from() + .select('row_key') + .or('createdAt.is.null') + + expect(error).toBeNull() + expect(data).toEqual([]) + }) + + // The `in()` method path, executed for the first time against a real server. + // Each element is its own quote-dense envelope, so the operand is the densest + // list PostgREST has to parse outside an or-tree. + it('matches an encrypted in-list through the in() method', async () => { + const { data, error } = await from() + .select('row_key') + .in('nickname', ['ada', 'nobody']) + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // The RAW filter path reached `in` with no element-split: the whole list was + // encrypted as one equality term, so the request parsed and returned zero + // rows. A mock records the emitted operand and cannot tell that apart from a + // correct one — only a real server proves the predicate selects `ada`. + it('matches an encrypted in-list through the raw filter() path', async () => { + const { data, error } = await from() + .select('row_key') + .filter('nickname', 'in', ['ada', 'nobody']) + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // The same call must still EXCLUDE a row whose value is absent from the list. + // Without this, a filter that matched everything would pass the test above. + it('excludes a row whose value is absent from a raw in-list', async () => { + const { data, error } = await from() + .select('row_key') + .filter('nickname', 'in', ['nobody', 'someone']) + + expect(error).toBeNull() + expect(data).toEqual([]) + }) + + // A PostgREST list literal cannot be encrypted element-wise; the adapter + // refuses it rather than emit a filter that silently matches nothing. + it('rejects a raw in-list passed as a PostgREST list literal', async () => { + const { error } = await from() + .select('row_key') + .filter('nickname', 'in', '("ada","nobody")') + + expect(error?.message).toMatch(/requires an array of values/) + }) + + // A plaintext column keeps postgrest-js's own encoding, untouched. Passing a + // list LITERAL is the only form its raw `.filter()` renders correctly. + it('leaves a raw in-list literal on a plaintext column to postgrest-js', async () => { + const { data, error } = await from() + .select('row_key') + .filter('row_key', 'in', '("ada","nobody")') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // Pins what we did NOT change. postgrest-js renders `.filter(col,'in',[…])` + // as an unparenthesized `in.ada,nobody`, which PostgREST rejects with + // PGRST100 — true of every plaintext column, before this change and after. + // The encrypted path cannot inherit that: it must take an array (nothing else + // can be encrypted element-wise) and so builds the literal itself. Asserting + // the asymmetry keeps a future "helpfully format plaintext arrays too" from + // landing unnoticed as a behaviour change. + it('does not rescue a raw in-list ARRAY on a plaintext column', async () => { + const { error } = await from() + .select('row_key') + .filter('row_key', 'in', ['ada', 'nobody']) + + expect(error?.code).toBe('PGRST100') + expect(error?.details).toContain('expecting "("') + }) + + // A caller-chosen alias keys the row by neither the property nor the DB name. + // PostgREST has to parse `ts:created_at::jsonb` and key the row `ts`, and the + // adapter has to follow that alias back to the column's `cast_as` to rebuild + // the `Date`. Both halves are only observable against a real server. + it('reconstructs a Date under a caller-chosen select alias', async () => { + const { data, error } = await from() + .select('row_key, ts:createdAt') + .eq('row_key', 'ada') + + expect(error).toBeNull() + expect(data).toHaveLength(1) + expect(data[0].ts).toBeInstanceOf(Date) + expect((data[0].ts as Date).toISOString()).toBe(ADA_CREATED.toISOString()) + }) + + it('updates and deletes through encrypted WHERE operands', async () => { + const updated = await from() + .update({ note: 'changed' }) + .eq('nickname', 'ada') + expect(updated.error).toBeNull() + + const deleted = await from().delete().eq('nickname', 'ada') + expect(deleted.error).toBeNull() + + const { data } = await from().select('row_key') + expect(data).toEqual([]) + }) +}) diff --git a/packages/stack-supabase/package.json b/packages/stack-supabase/package.json new file mode 100644 index 000000000..008358513 --- /dev/null +++ b/packages/stack-supabase/package.json @@ -0,0 +1,92 @@ +{ + "name": "@cipherstash/stack-supabase", + "version": "0.0.0", + "description": "CipherStash Stack Supabase integration: transparent, searchable field-level encryption for Supabase.", + "keywords": [ + "encrypted", + "encryption", + "searchable-encryption", + "security", + "supabase", + "postgres", + "cipherstash", + "stack" + ], + "bugs": { + "url": "https://github.com/cipherstash/stack/issues" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/cipherstash/stack.git", + "directory": "packages/stack-supabase" + }, + "license": "MIT", + "author": "CipherStash ", + "type": "module", + "main": "./dist/index.cjs", + "module": "./dist/index.js", + "types": "./dist/index.d.ts", + "sideEffects": false, + "files": [ + "dist", + "README.md" + ], + "exports": { + ".": { + "import": { + "types": "./dist/index.d.ts", + "default": "./dist/index.js" + }, + "require": { + "types": "./dist/index.d.cts", + "default": "./dist/index.cjs" + } + }, + "./package.json": "./package.json" + }, + "scripts": { + "prebuild": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"", + "build": "tsup", + "dev": "tsup --watch", + "test": "vitest run", + "test:types": "vitest --run --typecheck.only", + "test:integration": "vitest run --config integration/vitest.config.ts", + "analyze:complexity": "fta src --score-cap 91" + }, + "dependencies": { + "@cipherstash/stack": "workspace:*" + }, + "peerDependencies": { + "@supabase/supabase-js": ">=2", + "pg": ">=8" + }, + "peerDependenciesMeta": { + "@supabase/supabase-js": { + "optional": true + }, + "pg": { + "optional": true + } + }, + "devDependencies": { + "@cipherstash/protect-ffi": "0.29.0", + "@cipherstash/test-kit": "workspace:*", + "fta-cli": "3.0.0", + "@supabase/postgrest-js": "2.105.4", + "@supabase/supabase-js": "^2.110.0", + "@types/pg": "^8.20.0", + "fast-check": "^4.8.0", + "dotenv": "17.4.2", + "pg": "8.20.0", + "postgres": "^3.4.8", + "tsup": "catalog:repo", + "typescript": "catalog:repo", + "vitest": "catalog:repo" + }, + "publishConfig": { + "access": "public" + }, + "engines": { + "node": ">=22" + } +} diff --git a/packages/stack-supabase/src/helpers.ts b/packages/stack-supabase/src/helpers.ts new file mode 100644 index 000000000..d34697413 --- /dev/null +++ b/packages/stack-supabase/src/helpers.ts @@ -0,0 +1,674 @@ +import type { + EncryptedTable, + EncryptedTableColumn, +} from '@cipherstash/stack/schema' +import type { QueryTypeName } from '@cipherstash/stack/types' +import type { + DbFilterString, + DbPendingOrCondition, + DbSelect, + FilterOp, + PendingOrCondition, +} from './types' + +/** + * Get the names of all encrypted columns defined in a table schema. + */ +export function getEncryptedColumnNames( + schema: EncryptedTable, +): string[] { + const built = schema.build() + return Object.keys(built.columns) +} + +/** + * Check whether a column name refers to an encrypted column in the schema. + */ +export function isEncryptedColumn( + columnName: string, + encryptedColumnNames: string[], +): boolean { + return encryptedColumnNames.includes(columnName) +} + +/** + * Parse a Supabase select string and add `::jsonb` casts to encrypted columns. + * + * Input: `'id, email, name'` + * Output: `'id, email::jsonb, name::jsonb'` (if email and name are encrypted) + * + * Handles whitespace, already-cast columns, and embedded functions. + */ +export function addJsonbCasts( + columns: string, + encryptedColumnNames: string[], +): DbSelect { + // The mapping below emits DB-space tokens; the brand is asserted once, here. + return columns + .split(',') + .map((col) => { + const trimmed = col.trim() + + // Skip empty segments + if (!trimmed) return col + + // If it already has a cast (e.g. `email::jsonb`), skip + if (trimmed.includes('::')) return col + + // If it contains parens (function call) or dots (foreign table), skip + if (trimmed.includes('(') || trimmed.includes('.')) return col + + // Check if the column name (possibly with alias) is encrypted + // Handle `column_name` or `column_name as alias` + const parts = trimmed.split(/\s+/) + const colName = parts[0] + + if (isEncryptedColumn(colName, encryptedColumnNames)) { + // Preserve original whitespace before the column + const leadingWhitespace = col.match(/^(\s*)/)?.[1] ?? '' + if (parts.length > 1) { + // Has alias: `email as e` -> `email::jsonb as e` + return `${leadingWhitespace}${colName}::jsonb ${parts.slice(1).join(' ')}` + } + return `${leadingWhitespace}${colName}::jsonb` + } + + return col + }) + .join(',') as DbSelect +} + +/** + * Resolve a select token to its DB column name, or `undefined`. + * + * `Object.hasOwn` is required, not decorative: the token comes from the caller's + * select string (or, for `select('*')`, from the database's own column list). + * `buildColumnKeyMap()` already returns a null-prototype map, but an inherited + * `Object.prototype` member is truthy, so a plain-object map would let a column + * named `constructor` interpolate `function Object() { … }` into the emitted + * select string. Both guards are kept — a future refactor that drops the null + * prototype must not silently reopen the hole. + */ +function lookupDbName( + propToDb: Record, + token: string, +): string | undefined { + return Object.hasOwn(propToDb, token) ? propToDb[token] : undefined +} + +/** + * Parse a Supabase select string and add `::jsonb` casts to encrypted EQL v3 + * columns, resolving JS property names to DB column names via PostgREST + * aliasing. + * + * Input: `'id, email, createdAt'` with `{ email: 'email', createdAt: 'created_at' }` + * Output: `'id, email::jsonb, createdAt:created_at::jsonb'` + * + * - A property whose DB name differs is emitted as `prop:db_name::jsonb` + * (PostgREST rename syntax), so result rows come back keyed by the JS + * property name. + * - A DB column name used directly is cast in place (`db_name::jsonb`). + * - Tokens that already carry a cast, or contain parens/dots (functions, + * foreign tables), are left untouched — same rules as the v2 helper. + */ +export function addJsonbCastsV3( + columns: string, + propToDb: Record, +): DbSelect { + const dbNames = new Set(Object.values(propToDb)) + + return columns + .split(',') + .map((col) => { + const resolved = resolveSelectToken(col.trim(), propToDb, dbNames) + if (resolved === null) return col + + const leadingWhitespace = col.match(/^(\s*)/)?.[1] ?? '' + return `${leadingWhitespace}${resolved.emit}` + }) + .join(',') as DbSelect +} + +/** + * The result-row key each encrypted column comes back under for a given select + * string, mapped to its DB column name. + * + * The two differ whenever PostgREST renames: `createdAt` on a `created_at` + * column keys rows by `createdAt`, and a caller-chosen alias (`ts:createdAt`) + * keys them by `ts`. Consumers that resolve per-column config by DB name — + * `postprocessDecryptedRow` reading `cast_as` to rebuild `Date` values — need + * this bridge, because the row key alone does not identify the column. + * + * Shares {@link resolveSelectToken} with {@link addJsonbCastsV3} so the keys + * this reports are exactly the keys that helper causes PostgREST to emit. Any + * token the cast helper leaves untouched is absent here. + */ +export function selectKeyToDbV3( + columns: string, + propToDb: Record, +): Record { + const dbNames = new Set(Object.values(propToDb)) + const keyToDb: Record = Object.create(null) + + for (const col of columns.split(',')) { + const resolved = resolveSelectToken(col.trim(), propToDb, dbNames) + if (resolved !== null) keyToDb[resolved.key] = resolved.db + } + + return keyToDb +} + +/** + * Resolve one select-string token to the row key it produces, the DB column it + * names, and the `::jsonb`-cast text to emit for it. `null` for a token this + * helper does not rewrite: empty, already cast, a function call or foreign-table + * path (parens/dots), or a name belonging to no encrypted column. + */ +function resolveSelectToken( + trimmed: string, + propToDb: Record, + dbNames: ReadonlySet, +): { key: string; db: string; emit: string } | null { + if (!trimmed) return null + if (trimmed.includes('::')) return null + if (trimmed.includes('(') || trimmed.includes('.')) return null + + // Already-aliased token: `alias:column` + const aliasMatch = trimmed.match( + /^([A-Za-z_][A-Za-z0-9_]*):([A-Za-z_][A-Za-z0-9_]*)$/, + ) + if (aliasMatch) { + const [, alias, name] = aliasMatch + const db = + lookupDbName(propToDb, name) ?? (dbNames.has(name) ? name : undefined) + if (db === undefined) return null + return { key: alias, db, emit: `${alias}:${db}::jsonb` } + } + + const db = lookupDbName(propToDb, trimmed) + if (db !== undefined) { + return { + key: trimmed, + db, + emit: db === trimmed ? `${trimmed}::jsonb` : `${trimmed}:${db}::jsonb`, + } + } + + if (dbNames.has(trimmed)) { + return { key: trimmed, db: trimmed, emit: `${trimmed}::jsonb` } + } + + return null +} + +/** + * Whether a filter operand is a value to be encrypted and compared, rather than + * a SQL predicate. Every term collector must consult this before pushing an + * encryption term. + * + * - `is` is a predicate, not a comparison: PostgREST accepts only + * `null`/`true`/`false`/`unknown` after it, so an encrypted operand is + * rejected. The operand is non-null for `is(col, false)`, so the operator + * must be checked independently of the value. + * - A `null`/`undefined` operand is SQL NULL. A null plaintext is stored as a + * NULL column, not as ciphertext, so it is found with an unencrypted + * `IS NULL` — encrypting the operand can never match anything. + * + * `operator` is widened to `string` because raw `filter()` accepts any + * PostgREST operator, not just a {@link FilterOp}. + */ +export function isEncryptableTerm( + operator: FilterOp | string, + value: unknown, +): boolean { + if (operator === 'is') return false + return value != null +} + +/** + * Map a Supabase filter operation to a CipherStash query type. + */ +export function mapFilterOpToQueryType(op: FilterOp): QueryTypeName { + switch (op) { + case 'eq': + case 'neq': + case 'in': + case 'is': + return 'equality' + case 'like': + case 'ilike': + // `matches` is the encrypted free-text (bloom) operator. `contains` remains + // for completeness/v2 but is plaintext-only on the v3 surface, so it never + // reaches term encryption there (a plaintext operand is not encrypted). + case 'contains': + case 'matches': + return 'freeTextSearch' + case 'gt': + case 'gte': + case 'lt': + case 'lte': + return 'orderAndRange' + default: + return 'equality' + } +} + +/** + * Parse a Supabase `.or()` filter string into structured conditions. + * + * Input: `'email.eq.john@example.com,name.ilike.%john%'` + * Output: `[{ column: 'email', op: 'eq', negate: false, value: 'john@example.com' }, …]` + * + * PostgREST spells negation `column.not..`. It is lifted onto its own + * `negate` flag rather than left as the operator: the term collector keys the + * `in`-list split on `op === 'in'`, so a negated list parsed as + * `{ op: 'not', value: 'in.(a,b)' }` skipped the split and encrypted the literal + * string `in.(a,b)` as a single plaintext — a filter that silently matched + * nothing. Only a `not` in the OPERATOR position is a prefix; a column or value + * of that name is untouched. + */ +export function parseOrString(orString: string): PendingOrCondition[] { + const conditions: PendingOrCondition[] = [] + // Split on commas that are not inside parentheses (nested or/and) + const parts = splitTopLevel(orString) + + for (const part of parts) { + const trimmed = part.trim() + if (!trimmed) continue + + // Format: column.op.value — or column.not.op.value + const firstDot = trimmed.indexOf('.') + if (firstDot === -1) continue + + const column = trimmed.slice(0, firstDot) + let rest = trimmed.slice(firstDot + 1) + + let negate = false + if (rest.startsWith('not.')) { + const afterNot = rest.slice('not.'.length) + // `col.not..` needs an operator AND a value after the prefix. + // Without the second dot, `not` IS the operator (or the string is + // malformed) — leave it alone rather than swallow the operator. + if (afterNot.includes('.')) { + negate = true + rest = afterNot + } + } + + const secondDot = rest.indexOf('.') + if (secondDot === -1) continue + + const op = rest.slice(0, secondDot) as FilterOp + const value = rest.slice(secondDot + 1) + + // Handle special value formats + const parsedValue = parseOrValue(value, op) + + conditions.push({ column, op, negate, value: parsedValue }) + } + + return conditions +} + +/** + * PostgREST operator tokens whose operand is a CONTAINMENT literal — a + * Postgres array literal (`{vip,admin}`) or a jsonb literal (`{"a":1}`) — rather + * than a scalar or the `in`-list's `(a,b)`. + * + * `contains` is supabase-js's METHOD name for this operator; string-form `.or()` + * callers write PostgREST's `cs` directly. Both reach here. + */ +const CONTAINMENT_OPS = new Set(['contains', 'matches', 'cs']) + +/** + * The PostgREST operator token for a {@link FilterOp}. + * + * `contains` is the only member of the union that is a supabase-js method name + * rather than a PostgREST operator: `eq`, `in`, `like`, `is` and the rest spell + * the same on both sides, but PostgREST's containment operator is `cs`, and + * `or=(tags.contains.vip)` is a PGRST100 parse error ("unexpected \"c\" + * expecting \"not\" or operator"). + * + * Applied unconditionally, NOT only to encrypted conditions. The token depends + * on the operator, never on whether the operand was encrypted — a plaintext + * jsonb/array column reached through `.or([{op: 'contains'}])` needs exactly the + * same translation, and gating it on encryption is what left plaintext + * containment broken while the encrypted path worked. + */ +function orOperatorToken(op: string): string { + return op === 'contains' || op === 'matches' ? 'cs' : op +} + +/** + * Rebuild an `.or()` string from structured conditions. + */ +export function rebuildOrString( + conditions: DbPendingOrCondition[], +): DbFilterString { + // Callers must hand DB-space `c.column` values (see `toDbSpace`). + return conditions + .map((c) => { + const op = orOperatorToken(c.op) + const value = formatOrValue(c.value, op) + const token = c.negate ? `not.${op}` : op + return `${c.column}.${token}.${value}` + }) + .join(',') as DbFilterString +} + +// --------------------------------------------------------------------------- +// Internal helpers +// --------------------------------------------------------------------------- + +/** A logic-group token: the only non-operand position an opener may follow. */ +const OR_GROUP_TOKEN = /^(?:not\.)?(?:and|or)$/ + +/** + * Split on the commas that separate top-level tokens, leaving those inside a + * quoted operand or a `(…)` / `{…}` literal alone. + * + * Quotes are tracked at EVERY depth. A quoted string is opaque wherever it + * appears, and an array literal quotes any element carrying a reserved character + * (see {@link arrayLiteralElement}) — so `{"a}b"}` closes at the LAST brace, not + * the one inside the element. Tracking quotes only at depth 0 ended the literal + * early and swallowed the following condition into this operand. + * + * Braces and parens count as STRUCTURE only where PostgREST's grammar can put + * them: opening a logic group (`and(`, `or(`, and their `not.` forms), opening + * an operand (immediately after the operator dot — `col.cs.{…}`, `col.in.(…)`), + * or nested inside a literal already open. `}` and `)` are not PostgREST + * reserved characters and `{`/`(` are not reserved mid-operand, so `a}b` and + * `a{b` are valid unquoted scalars. Counting those as structure desynchronised + * the split: a stray closer drove `depth` negative and a stray opener stranded + * it above zero, and either way no later comma split — every remaining condition + * was silently absorbed into this operand. + * + * `current === ''` admits a literal at the start of a token, which is how the + * `in`-list reuse below sees `{"a":1},{"b":2}`. + * + * The rule still reads a `{` after an in-value dot (`x.eq.a.{b`) as an operand + * opener. `depth !== 0` at the end proves the counting was fooled, so the pass + * is discarded and the input re-split honouring quotes alone — a backstop, not + * the primary mechanism. It must stay narrow: applied to an input whose braces + * WERE structure, it re-splits inside `{vip,admin}` and `parseOrString` then + * drops the dotless `admin}` fragment. + * + * `trackDepth` is the recursion's own flag, never passed by callers. NEVER + * throws — `query-builder.ts` relies on `parseOrString` being total so that + * capability errors surface in filter order. + */ +function splitTopLevel(input: string, trackDepth = true): string[] { + const parts: string[] = [] + let current = '' + let depth = 0 + let inQuotes = false + + let escaped = false + + for (const char of input) { + // A backslash-escaped character is literal: `\"` must NOT toggle `inQuotes`, + // or an escaped quote inside an encrypted operand would end the token and + // the next comma would split mid-value. + if (escaped) { + escaped = false + current += char + } else if (char === '\\' && inQuotes) { + escaped = true + current += char + } else if (char === '"') { + inQuotes = !inQuotes + current += char + } else if ( + trackDepth && + (char === '(' || char === '{') && + !inQuotes && + // `{` as well as `(`: a containment operand is an array (`{vip,admin}`) or + // a jsonb (`{"a":1,"b":2}`) literal, whose top-level commas are part of + // the value. PostgREST's own logic-tree parser tracks these braces; + // without them a condition splits mid-literal into `tags.cs.{vip` and a + // dotless fragment `admin}` that the loop below silently drops. Only at a + // token boundary, though — mid-operand the character is just data. + (depth > 0 || + current === '' || + current.endsWith('.') || + OR_GROUP_TOKEN.test(current)) + ) { + depth++ + current += char + } else if ( + trackDepth && + (char === ')' || char === '}') && + !inQuotes && + depth > 0 + ) { + depth -= 1 + current += char + } else if (char === ',' && depth === 0 && !inQuotes) { + parts.push(current) + current = '' + } else { + current += char + } + } + + parts.push(current) + + // An opener that was never structure (`note.eq.a{b,…`) left depth stranded and + // swallowed every condition behind it. Re-split without depth: quotes alone. + if (trackDepth && depth !== 0) return splitTopLevel(input, false) + + return parts +} + +/** + * One element of an `in`-list operand, undoing {@link formatOrValue}'s quoting. + * Unquoted elements are trimmed, as PostgREST ignores whitespace around them; + * inside quotes it is significant. + */ +function parseInListElement(element: string): string { + const trimmed = element.trim() + if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) { + return unescapeOrValue(trimmed.slice(1, -1)) + } + return trimmed +} + +/** + * PostgREST operators whose operand is delimited by parentheses: the `in` list + * and the range operators. Everywhere else `(` is an ordinary character, and a + * parenthesized operand is a scalar that happens to start with one. + * + * The range operators earn their place by round-trip fidelity rather than by + * encryption: none is supported on an encrypted column, but an or-string is + * rebuilt whole as soon as ANY of its conditions names one, so a plaintext + * `period.ov.(1,10)` sharing the group must re-emit byte-for-byte. + */ +const PAREN_OPERAND_OPS = new Set(['in', 'ov', 'sl', 'sr', 'nxr', 'nxl', 'adj']) + +/** + * @param op the operator the value belongs to, already stripped of any `not.` + * prefix. Parsing a parenthesized scalar as an array meant an encrypted `eq` + * operand was encrypted as a JS array rather than the intended string, and the + * filter matched nothing. + */ +function parseOrValue(value: string, op?: string): unknown { + // Handle double-quoted values (PostgREST quoting for reserved characters). + // Must undo `escapeOrValue`, or a parse → rebuild round-trip doubles every + // backslash. The two functions are only correct as a pair. + if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) { + return unescapeOrValue(value.slice(1, -1)) + } + + // Handle parenthesized lists: (val1,val2,val3). Elements are quoted exactly as + // any other operand, so the split must respect those quotes: `("a,b",c)` is + // two elements, not three. + if ( + op !== undefined && + PAREN_OPERAND_OPS.has(op) && + value.startsWith('(') && + value.endsWith(')') + ) { + return splitTopLevel(value.slice(1, -1)).map(parseInListElement) + } + + // Handle booleans + if (value === 'true') return true + if (value === 'false') return false + + // Handle null + if (value === 'null') return null + + return value +} + +/** + * PostgREST characters that require double-quoting in filter values. + * + * `"` and `\` are here because a value containing either must be quoted AND + * escaped: unquoted, a bare `"` is a syntax error mid-value; quoted but + * unescaped, it terminates the value early. Every v3 encrypted operand is + * `JSON.stringify(envelope)`, so this is the common case, not the exotic one. + * + * See: https://docs.postgrest.org/en/latest/references/api/tables_views.html + */ +const POSTGREST_RESERVED = /["\\,().]/ + +/** + * The reserved set for a SCALAR operand: {@link POSTGREST_RESERVED} plus the + * braces. + * + * A brace is structure to PostgREST's logic-tree parser inside `or=(…)`, and to + * {@link splitTopLevel} on the way back in, so an unquoted `a{b` is malformed on + * the wire AND desynchronises our own parse — the condition behind it is absorbed + * into this operand and silently dropped. Every character the parser reacts to + * must be quoted here. + * + * Deliberately NOT used for containment literals: those are `{…}` by + * construction, and quoting them on the brace alone would turn `tags.cs.{vip}` + * into `tags.cs."{vip}"`. Both spellings parse, but the bare one is what + * PostgREST documents and what the tests pin. + */ +const POSTGREST_RESERVED_SCALAR = /["\\,(){}.]/ + +/** + * Operands PostgREST reads as SQL values rather than as the string spelling + * them. A STRING operand that happens to spell one must be quoted, or + * `name.eq.null` compares against SQL NULL — a filter that matches nothing — + * instead of against the three-character string. + */ +const POSTGREST_RESERVED_WORDS = new Set(['null', 'true', 'false']) + +/** Escape `\` first, then `"` — the reverse order would double-escape. */ +function escapeOrValue(str: string): string { + return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"') +} + +/** Inverse of {@link escapeOrValue}: consume `\x` as a literal `x`. */ +function unescapeOrValue(str: string): string { + return str.replace(/\\(.)/g, '$1') +} + +/** + * Characters that force an ARRAY-literal element to be double-quoted. Wider + * than {@link POSTGREST_RESERVED} because the braces and whitespace that are + * harmless in a scalar operand are structural inside `{…}`. + */ +const ARRAY_ELEMENT_RESERVED = /[,"\\{}()\s]/ + +/** One element of a Postgres array literal. `NULL` is a keyword there, so a + * string that happens to spell it must be quoted to stay a string. */ +function arrayLiteralElement(value: unknown): string { + if (value === null || value === undefined) return 'NULL' + const str = String(value) + if (str === '' || ARRAY_ELEMENT_RESERVED.test(str) || /^null$/i.test(str)) { + return `"${escapeOrValue(str)}"` + } + return str +} + +/** + * The `cs` operand for a structured value: `{a,b}` for an array column, + * `{"a":1}` for a jsonb one. Returns null when `value` is a scalar, which takes + * the ordinary path — notably the v3 encrypted operand, already a + * `JSON.stringify`d envelope STRING, which must not be re-serialized. + */ +function containmentLiteral(value: unknown): string | null { + if (Array.isArray(value)) { + return `{${value.map((v) => arrayLiteralElement(v)).join(',')}}` + } + if (value !== null && typeof value === 'object' && !(value instanceof Date)) { + return JSON.stringify(value) + } + return null +} + +function formatOrValue(value: unknown, op?: string): string { + // A containment literal is a VALUE like any other once built: it goes on to + // the quoting below, because its comma would otherwise split the or-string at + // the top level. PostgREST accepts a quoted `"{vip,admin}"` inside `or=(…)`. + if (op !== undefined && CONTAINMENT_OPS.has(op)) { + const literal = containmentLiteral(value) + // Quoted on the NARROW set, not the scalar one: a containment literal is + // always brace-delimited, so the scalar set would quote every one of them. + // Its own braces are balanced and `splitTopLevel` counts them correctly. + if (literal !== null) { + return POSTGREST_RESERVED.test(literal) + ? `"${escapeOrValue(literal)}"` + : literal + } + } + + if (Array.isArray(value)) { + return `(${value.map((v) => formatOrValue(v)).join(',')})` + } + if (value === null) return 'null' + if (value === true) return 'true' + if (value === false) return 'false' + + const str = String(value) + + // Wrap in double quotes if the value contains reserved characters. + // This is required for encrypted values (JSON with commas, braces, etc.) + // and is safe for all string values per PostgREST spec. + if ( + POSTGREST_RESERVED_SCALAR.test(str) || + POSTGREST_RESERVED_WORDS.has(str) + ) { + return `"${escapeOrValue(str)}"` + } + + return str +} + +/** + * The operand for an `in`/`not.in` list: `(a,b)`, each element quoted and + * escaped exactly as the `or` path does. + * + * Required because postgrest-js's own `in()` wraps a comma-bearing element in + * `"…"` but never escapes the `"` already inside it — and every v3 encrypted + * operand is a `JSON.stringify`d envelope, so its quotes would terminate the + * value early. Emit this through `filter(col, 'in', …)` / `not(col, 'in', …)`, + * both of which forward the operand verbatim. + */ +export function formatInListOperand(values: readonly unknown[]): string { + return formatOrValue([...values]) +} + +/** + * The operand for a direct `cs`/`contains` filter: `{a,b}` for an array, + * `{"a":1}` for a jsonb object, `null` for a scalar. + * + * `null` means "not a structured operand" — the caller forwards the value as it + * stands. That covers both a plaintext string (`cs.plain`) and the v3 encrypted + * envelope, which is already `JSON.stringify`d and must not be re-serialized. + * + * Required because postgrest-js builds an array operand as `{${value.join(',')}}` + * with no element quoting, so an element carrying a comma becomes two elements; + * and its `not()` stringifies the operand outright, dropping the braces and + * rendering an object as `[object Object]`. The `.or()` path formats containment + * operands through the same {@link containmentLiteral}; emit them identically + * here, or the two paths disagree on what the same call means. + */ +export function formatContainmentOperand(value: unknown): string | null { + return containmentLiteral(value) +} diff --git a/packages/stack-supabase/src/index.ts b/packages/stack-supabase/src/index.ts new file mode 100644 index 000000000..6b3af298c --- /dev/null +++ b/packages/stack-supabase/src/index.ts @@ -0,0 +1,306 @@ +import { Encryption } from '@cipherstash/stack' +import type { + EncryptedTable, + EncryptedTableColumn, +} from '@cipherstash/stack/schema' +import type { UnmodelledColumn } from './introspect' +import { introspect } from './introspect' +import { EncryptedQueryBuilderImpl } from './query-builder' +import { EncryptedQueryBuilderV3Impl } from './query-builder-v3' +import { mergeDeclaredTables, synthesizeTables } from './schema-builder' +import type { + EncryptedQueryBuilder, + EncryptedSupabaseConfig, + EncryptedSupabaseInstance, + EncryptedSupabaseV3Instance, + EncryptedSupabaseV3Options, + SupabaseClientLike, + TypedEncryptedSupabaseV3Instance, + V3Schemas, +} from './types' +import { verifyDeclaredSchemas } from './verify' + +/** + * Create an encrypted Supabase wrapper that transparently handles encryption + * and decryption for queries on encrypted columns. + * + * @param config - Configuration containing the encryption client and Supabase client. + * @returns An object with a `from()` method that mirrors `supabase.from()` but + * auto-encrypts mutations, adds `::jsonb` casts, encrypts filter values, and + * decrypts results. + * + * @example + * ```typescript + * import { Encryption } from '@cipherstash/stack' + * import { encryptedSupabase } from '@cipherstash/stack-supabase' + * import { encryptedTable, encryptedColumn } from '@cipherstash/stack/schema' + * + * const users = encryptedTable('users', { + * name: encryptedColumn('name').freeTextSearch().equality(), + * email: encryptedColumn('email').freeTextSearch().equality(), + * }) + * + * const client = await Encryption({ schemas: [users] }) + * const eSupabase = encryptedSupabase({ encryptionClient: client, supabaseClient: supabase }) + * + * // INSERT - auto-encrypts, auto-converts to PG composite + * await eSupabase.from('users', users) + * .insert({ name: 'John', email: 'john@example.com', age: 30 }) + * + * // SELECT with filter - auto-casts ::jsonb, auto-encrypts search term, auto-decrypts + * const { data } = await eSupabase.from('users', users) + * .select('id, email, name') + * .eq('email', 'john@example.com') + * ``` + */ +export function encryptedSupabase( + config: EncryptedSupabaseConfig, +): EncryptedSupabaseInstance { + const { encryptionClient, supabaseClient } = config + + return { + from = Record>( + tableName: string, + schema: EncryptedTable, + ) { + return new EncryptedQueryBuilderImpl( + tableName, + schema, + encryptionClient, + supabaseClient, + ) + }, + } +} + +/** + * Throw if `tableName` carries an EQL v3 column this SDK version cannot model. + * + * Such a column is a silent data leak: it never enters the encrypt config, but + * it IS in `allColumns`, so `select('*')` selects it and `decryptModel` skips + * it — the caller gets raw ciphertext typed as data. (Writes fail loudly on the + * domain CHECK; only reads are silent.) + * + * Keyed by table, not applied to the whole schema, because the hazard exists + * only for a table the caller actually queries. An `audit_log.payload + * public.eql_v3_json` column on a table you never name cannot leak, and must not stop + * you constructing a client for `users`. + */ +function assertTableIsModelled( + tableName: string, + unmodelled: Map, +): void { + const columns = unmodelled.get(tableName) + if (!columns?.length) return + const detail = columns + .map((c) => `"${tableName}.${c.columnName}" (public.${c.domainName})`) + .join(', ') + throw new Error( + `[supabase v3]: table "${tableName}" has EQL v3 columns this @cipherstash/stack version does not model: ${detail}. Upgrade the package, or stop using this table — the columns cannot be plaintext passthroughs (reads would return ciphertext undecrypted).`, + ) +} + +/** + * Create an encrypted Supabase wrapper for **EQL v3** schemas by introspecting + * the database at connect time. Detects EQL v3 columns by their Postgres domain + * and derives each column's encryption config from it — callers no longer pass a + * schema to `from()`. Supplying `schemas` is optional: it adds compile-time + * types and verifies the declared tables against the database at construction. + * + * Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for + * introspection, so it cannot run in a Worker or the browser. + * + * A column is an EQL v3 column when its type is one of the `public` domains the + * EQL v3 bundle installs. The domain names the capabilities, and introspection + * turns it into the column's encryption config: + * + * ```sql + * CREATE TABLE users ( + * id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + * email public.eql_v3_text_search, -- equality, ordering, free-text match + * age public.eql_v3_integer_ord, -- equality, ordering + * name text -- plaintext passthrough, untouched + * ); + * ``` + * + * @example + * ```typescript + * const supabase = await encryptedSupabaseV3(supabaseUrl, supabaseKey) + * await supabase.from('users').insert({ email: 'alice@example.com' }) + * const { data } = await supabase.from('users').select().eq('email', 'alice@example.com') + * ``` + */ +export async function encryptedSupabaseV3( + supabaseUrl: string, + supabaseKey: string, + options: EncryptedSupabaseV3Options & { schemas: S }, +): Promise> +export async function encryptedSupabaseV3( + supabaseUrl: string, + supabaseKey: string, + options?: EncryptedSupabaseV3Options, +): Promise +export async function encryptedSupabaseV3( + supabaseClient: SupabaseClientLike, + options: EncryptedSupabaseV3Options & { schemas: S }, +): Promise> +export async function encryptedSupabaseV3( + supabaseClient: SupabaseClientLike, + options?: EncryptedSupabaseV3Options, +): Promise +// The implementation's option params are `EncryptedSupabaseV3Options`, NOT ``. The no-schemas overloads take +// `EncryptedSupabaseV3Options` — i.e. ``, whose `schemas` is typed +// `undefined` — and TS2394s against an implementation param whose `schemas` is +// typed `V3Schemas`. Widening the type argument to the full constraint makes +// every overload relatable to the implementation signature. +export async function encryptedSupabaseV3( + clientOrUrl: SupabaseClientLike | string, + keyOrOptions?: string | EncryptedSupabaseV3Options, + maybeOptions?: EncryptedSupabaseV3Options, +): Promise< + EncryptedSupabaseV3Instance | TypedEncryptedSupabaseV3Instance +> { + // 1. Resolve the Supabase client + options from the overload shape. + let supabaseClient: SupabaseClientLike + let options: EncryptedSupabaseV3Options + if (typeof clientOrUrl === 'string') { + const url = clientOrUrl + const key = keyOrOptions as string + options = maybeOptions ?? {} + // `@supabase/supabase-js` is an optional peer: the url+key overload needs it + // to construct a client, but the (client) overload does not. Remap a missing + // install to an actionable message, matching `loadPg`. Guard on `err.code` + // (CJS `MODULE_NOT_FOUND`, ESM `ERR_MODULE_NOT_FOUND`), not message text. + let createClient: (url: string, key: string) => unknown + try { + ;({ createClient } = await import('@supabase/supabase-js')) + } catch (err) { + const code = (err as { code?: string }).code + if (code !== 'MODULE_NOT_FOUND' && code !== 'ERR_MODULE_NOT_FOUND') + throw err + throw new Error( + "[supabase v3]: encryptedSupabaseV3(url, key) needs '@supabase/supabase-js' " + + 'to build the client, but that optional peer dependency is not installed. ' + + 'Install it (`npm install @supabase/supabase-js`), or pass an existing ' + + 'client: encryptedSupabaseV3(supabaseClient, options).', + { cause: err }, + ) + } + supabaseClient = createClient(url, key) as unknown as SupabaseClientLike + } else { + supabaseClient = clientOrUrl + options = + (keyOrOptions as EncryptedSupabaseV3Options) ?? {} + } + + // 2. Resolve the database URL for introspection. + const databaseUrl = options.databaseUrl ?? process.env.DATABASE_URL + if (!databaseUrl) { + throw new Error( + '[supabase v3]: no database URL — pass options.databaseUrl or set the DATABASE_URL environment variable', + ) + } + + // 3. Introspect. Unmodelled EQL columns are NOT a construction-time veto — + // they are checked per table, at the point the caller names one. + const { tables, unmodelled } = await introspect(databaseUrl) + + // 4. Synthesize; if declared, guard record keys, verify, then merge. + // A DECLARED table is one the caller named, so it is validated eagerly, + // before the encryption client is built. + let synth = synthesizeTables(tables) + if (options.schemas) { + for (const [key, table] of Object.entries(options.schemas)) { + if (key !== table.tableName) { + throw new Error( + `[supabase v3]: schemas key "${key}" does not match its table name "${table.tableName}" — the record key must equal the table's name`, + ) + } + assertTableIsModelled(key, unmodelled) + } + verifyDeclaredSchemas(options.schemas, tables) + synth = mergeDeclaredTables(synth, options.schemas) + } + + // 5. Build the raw (eqlVersion 3) encryption client from the merged tables. + // NB: `Encryption`, not `EncryptionV3` — the query builder consumes the raw + // chainable `EncryptionClient`, whereas `EncryptionV3` returns the typed + // wrapper whose `decryptModel` returns a plain Promise. Pass only + // tables that carry at least one encrypted column (`Encryption` requires a + // non-empty schema list). + const encryptionSchemas = [...synth.tables.values()].filter( + (t) => Object.keys(t.columnBuilders).length > 0, + ) + + // A database with no modelled EQL v3 columns anywhere would hand `Encryption` + // an empty array, which throws "[encryption]: At least one encryptedTable must + // be provided to initialize the encryption client" (encryption/index.ts:693). + // That message is about a caller-supplied schema list the caller never + // supplied — actively misleading here. Fail with a diagnosis instead. The + // realistic causes are: EQL v3 is not installed, the tables live outside the + // `public` schema, or the columns were never migrated to `eql_v3` domains. + if (encryptionSchemas.length === 0) { + throw new Error( + '[supabase v3]: no EQL v3 encrypted columns found in schema "public". ' + + 'Check that EQL v3 is installed (`stash eql install --eql-version 3`) ' + + 'and that at least one column uses an eql_v3 domain type.', + ) + } + + const encryptionClient = await Encryption({ + schemas: encryptionSchemas as unknown as Parameters< + typeof Encryption + >[0]['schemas'], + config: { ...options.config, eqlVersion: 3 }, + }) + + // 6. Return the instance. `from` resolves the introspected/merged table and + // threads the full column list for select('*'). Casts are localized to the + // builder/instance boundary (this-chaining does not match structurally), + // NOT `as any` — the four overloads above remain the caller-facing contract. + const instance = { + from(tableName: string) { + const table = synth.tables.get(tableName) + if (!table) { + throw new Error( + `[supabase v3]: unknown table "${tableName}" — it was not found during introspection`, + ) + } + // Unconditional: `synthesizeTables` silently drops unmodelled columns, so + // this is the only thing preventing `select('*')` from returning raw + // ciphertext for one. Never make it optional. + assertTableIsModelled(tableName, unmodelled) + const allColumns = synth.allColumns.get(tableName) ?? null + return new EncryptedQueryBuilderV3Impl( + tableName, + table, + encryptionClient, + supabaseClient, + allColumns, + ) as unknown as EncryptedQueryBuilder> + }, + } + return instance as unknown as + | EncryptedSupabaseV3Instance + | TypedEncryptedSupabaseV3Instance +} + +export type { + EncryptedQueryBuilder, + EncryptedQueryBuilderCore, + EncryptedQueryBuilderV3, + EncryptedQueryBuilderV3Untyped, + EncryptedSupabaseConfig, + EncryptedSupabaseError, + EncryptedSupabaseInstance, + EncryptedSupabaseResponse, + EncryptedSupabaseV3Instance, + EncryptedSupabaseV3Options, + PendingOrCondition, + SupabaseClientLike, + TypedEncryptedSupabaseV3Instance, + V3FilterableKeys, + V3FreeTextSearchableKeys, + V3Schemas, +} from './types' diff --git a/packages/stack-supabase/src/introspect.ts b/packages/stack-supabase/src/introspect.ts new file mode 100644 index 000000000..9c126d6ab --- /dev/null +++ b/packages/stack-supabase/src/introspect.ts @@ -0,0 +1,214 @@ +import { DOMAIN_REGISTRY } from '@cipherstash/stack/adapter-kit' + +/** One introspected column: its DB name and its `public` EQL v3 domain (or `null`). */ +export interface IntrospectedColumn { + columnName: string + domainName: string | null +} + +/** One introspected base table with its columns in ordinal order. */ +export interface IntrospectedTable { + tableName: string + columns: IntrospectedColumn[] +} + +export type IntrospectionResult = IntrospectedTable[] + +/** + * Raw `information_schema` column row. `domain_name` is the column's domain when + * that domain lives in `public`, else `NULL` (the query nulls out non-`public` + * domains — see the CASE below), so a same-named domain in another schema is + * never mistaken for an EQL v3 domain. + */ +export interface IntrospectionRow { + table_name: string + column_name: string + domain_name: string | null +} + +/** One column carrying an EQL v3 domain this SDK version cannot model. */ +export interface UnmodelledColumn { + columnName: string + domainName: string +} + +/** + * Tables, plus the EQL v3 columns this SDK cannot model, keyed by table name. + * + * `unmodelled` is deliberately a per-table index rather than a flat list: such + * a column is a silent-leak hazard ONLY for a table the caller actually + * queries, so the guard is a lookup at `from()`, not a whole-schema veto at + * construction. A table absent from this map is safe to serve. + */ +export interface IntrospectionData { + tables: IntrospectionResult + unmodelled: Map +} + +/** Raw row of {@link UNMODELLED_COLUMNS_QUERY}. */ +export interface UnmodelledRow { + table_name: string + column_name: string + domain_name: string +} + +/** Group unmodelled-column rows by table name. */ +export function groupUnmodelledRows( + rows: UnmodelledRow[], +): Map { + const byTable = new Map() + for (const row of rows) { + let cols = byTable.get(row.table_name) + if (!cols) { + cols = [] + byTable.set(row.table_name, cols) + } + cols.push({ columnName: row.column_name, domainName: row.domain_name }) + } + return byTable +} + +/** + * Group flat `information_schema` rows into tables. Row order is the query's + * `ORDER BY table_name, ordinal_position`, so pushing in order preserves both + * table grouping and per-table column order. + */ +export function groupIntrospectionRows( + rows: IntrospectionRow[], +): IntrospectionResult { + const byTable = new Map() + const order: string[] = [] + for (const row of rows) { + let cols = byTable.get(row.table_name) + if (!cols) { + cols = [] + byTable.set(row.table_name, cols) + order.push(row.table_name) + } + cols.push({ columnName: row.column_name, domainName: row.domain_name }) + } + return order.map((tableName) => ({ + tableName, + columns: byTable.get(tableName) as IntrospectedColumn[], + })) +} + +// DELIBERATE FORK of packages/cli/src/commands/init/lib/introspect.ts — keep the +// two in sync. `stack` cannot depend on `cli`, and the projections differ: the +// CLI detects v2 composites via `udt_name = 'eql_v2_encrypted'`; this reads v3 +// domains via `domain_name`. `udt_name` is `jsonb` for a v3 domain column, so it +// cannot be reused here. +const COLUMNS_QUERY = ` + SELECT + c.table_name, + c.column_name, + CASE WHEN c.domain_schema = 'public' THEN c.domain_name ELSE NULL END + AS domain_name + FROM information_schema.columns c + JOIN information_schema.tables t + ON t.table_name = c.table_name AND t.table_schema = c.table_schema + WHERE c.table_schema = 'public' + AND t.table_type = 'BASE TABLE' + ORDER BY c.table_name, c.ordinal_position +` + +// The authoritative EQL-domain signal is the domain's COMMENT: every EQL v3 +// domain in the bundle is `COMMENT ON DOMAIN public. IS 'EQL…'` (89/89, +// zero exceptions). The CHECK bodies are NOT usable — they are non-uniform +// (`integer_ord` names no function; `json` calls a `public.eql_v3_*` function). +// `obj_description(oid, 'pg_type')` reads that comment for a domain type. +// +// INVERTED: rather than fetching all 89 EQL domain names and re-deriving the +// offenders client-side, push the modelled set ($1) into the predicate and +// return only the columns this SDK cannot model. The registry IS the query +// parameter, so the two cannot drift. +const UNMODELLED_COLUMNS_QUERY = ` + SELECT c.table_name, c.column_name, c.domain_name + FROM information_schema.columns c + JOIN information_schema.tables t + ON t.table_name = c.table_name AND t.table_schema = c.table_schema + JOIN pg_type tp ON tp.typname = c.domain_name + JOIN pg_namespace ns + ON ns.oid = tp.typnamespace AND ns.nspname = c.domain_schema + WHERE c.table_schema = 'public' + AND t.table_type = 'BASE TABLE' + AND c.domain_schema = 'public' + AND tp.typtype = 'd' + AND obj_description(tp.oid, 'pg_type') LIKE 'EQL%' + AND c.domain_name <> ALL ($1::text[]) + ORDER BY c.table_name, c.ordinal_position +` + +/** `pg` ships its API on the CJS default export, not the module namespace. */ +type PgDefaultExport = typeof import('pg')['default'] + +/** + * `pg` is an optional peer dependency, so a missing install surfaces here as a + * module-resolution error. Remap it to the actionable message; let every other + * failure propagate. Guard on `err.code` rather than message text — CJS throws + * `MODULE_NOT_FOUND`, ESM throws `ERR_MODULE_NOT_FOUND`. + * + * `importPg` is injectable because `vi.mock` cannot reproduce a module that + * fails to resolve — it replaces any factory rejection with its own error, + * discarding the `code` this function branches on. + * + * @internal + */ +export async function loadPg( + importPg: () => Promise<{ default: PgDefaultExport }> = () => import('pg'), +) { + try { + const { default: pg } = await importPg() + return pg + } catch (err) { + const code = (err as { code?: string }).code + if (code !== 'MODULE_NOT_FOUND' && code !== 'ERR_MODULE_NOT_FOUND') + throw err + throw new Error( + '[supabase v3]: encryptedSupabaseV3 introspects the database over a direct ' + + "Postgres connection, but the optional peer dependency 'pg' is not installed. " + + 'Install it (`npm install pg`). This also means encryptedSupabaseV3 cannot run ' + + 'in a Worker or the browser — use encryptedSupabase (EQL v2) there.', + { cause: err }, + ) + } +} + +/** + * Connect over `databaseUrl`, read every base table in the `public` schema with + * its EQL v3 domain (`domain_name`), plus the EQL v3 columns this SDK cannot + * model, indexed by table. `pg` is loaded with a dynamic import so bundlers do + * not pull it in unless introspection runs. + * + * `udt_name` is `jsonb` for a domain column, so ONLY `domain_name` distinguishes + * an EQL v3 column from a plain `jsonb` column (whose `domain_name` is NULL). + */ +export async function introspect( + databaseUrl: string, +): Promise { + const pg = await loadPg() + // Mirror the CLI introspector's bounded connect so an unreachable DB fails + // fast rather than hanging construction. + const client = new pg.Client({ + connectionString: databaseUrl, + connectionTimeoutMillis: 10_000, + }) + await client.connect() + try { + const [columns, unmodelled] = await Promise.all([ + client.query(COLUMNS_QUERY), + client.query(UNMODELLED_COLUMNS_QUERY, [ + Object.keys(DOMAIN_REGISTRY), + ]), + ]) + return { + tables: groupIntrospectionRows(columns.rows), + unmodelled: groupUnmodelledRows(unmodelled.rows), + } + } finally { + // `end()` runs only after a successful connect; swallow its own failure so it + // can never mask a query error (and, on the connect-failure path above, + // `connect()` throws before this try/finally is entered at all). + await client.end().catch(() => {}) + } +} diff --git a/packages/stack-supabase/src/query-builder-v3.ts b/packages/stack-supabase/src/query-builder-v3.ts new file mode 100644 index 000000000..608661ef6 --- /dev/null +++ b/packages/stack-supabase/src/query-builder-v3.ts @@ -0,0 +1,733 @@ +import { + DATE_LIKE_CASTS, + EncryptedV3Column, + logger, +} from '@cipherstash/stack/adapter-kit' +import type { EncryptionClient } from '@cipherstash/stack/encryption' +import type { AnyV3Table } from '@cipherstash/stack/eql/v3' +import { + type EncryptionError, + EncryptionErrorTypes, +} from '@cipherstash/stack/errors' +import type { + ColumnSchema, + EncryptedTable, + EncryptedTableColumn, +} from '@cipherstash/stack/schema' +import type { + BuildableQueryColumn, + Encrypted, + EncryptedQueryResult, + QueryTypeName, + ScalarQueryTerm, +} from '@cipherstash/stack/types' +import { addJsonbCastsV3, selectKeyToDbV3 } from './helpers' +import { + EncryptedQueryBuilderImpl, + EncryptionFailedError, +} from './query-builder' +import type { + DbName, + DbSelect, + FilterOp, + SupabaseClientLike, + SupabaseQueryBuilder, +} from './types' + +/** cast_as kinds that reconstruct to a JS `Date` — shared with the typed v3 + * client's decrypt-model path (see `encryption/v3.ts`). */ +const DATE_LIKE_CAST_SET = new Set(DATE_LIKE_CASTS) + +/** + * The subset of a v3 column builder the dialect relies on. Structural rather + * than the concrete class union so the runtime `instanceof EncryptedV3Column` + * gate and this type stay independent. + */ +type V3ColumnLike = { + getName(): string + getEqlType(): string + getQueryCapabilities(): { + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean + } + build(): ColumnSchema +} + +/** + * Reject a declared property name that is also a DIFFERENT physical column. + * + * `select('*')` expands the introspected DB names into property names, so a + * column renamed `created_at → createdAt` and a distinct plaintext column + * literally named `createdAt` both emit the token `createdAt`, which + * `addJsonbCastsV3` turns into `createdAt:created_at::jsonb` — twice. PostgREST + * returns the encrypted column under that key and the plaintext one is never + * selected, silently yielding the wrong value for a field the row type + * guarantees. + * + * Nothing downstream can disambiguate the two, and `EncryptedTable.build()`'s + * duplicate check only fires when two BUILDERS share a `getName()`. Refuse to + * construct instead. + */ +function assertNoPropertyDbNameCollision( + tableName: string, + propToDb: Record, + allColumns: string[] | null, +): void { + if (!allColumns) return + const dbNames = new Set(allColumns) + + for (const [property, dbName] of Object.entries(propToDb)) { + if (property === dbName) continue + if (!dbNames.has(property)) continue + throw new Error( + `[supabase v3]: property "${property}" on table "${tableName}" renames DB column "${dbName}", but "${property}" is also a distinct column in the database — the two collide in select('*'). Rename the property, or drop the declared rename.`, + ) + } +} + +/** + * EQL v3 dialect of {@link EncryptedQueryBuilderImpl} for native concrete-domain + * columns (`public.*` type domains, `eql_v3` operators). The query mechanism is + * v2's — direct EQL operators over PostgREST — with four narrow forks: + * + * - **Column recognition / naming** — v3 columns are `EncryptedV3Column` + * builders and may map a JS property name to a different DB column name + * (`buildColumnKeyMap`). Filters, select casts, and mutations resolve + * property → DB name; select casts alias the DB column back to the property + * (`prop:db_name::jsonb`) so result rows keep property keys. + * - **Mutation encoding** — the raw encrypted payload object is sent (the + * `public.*` domains are `DOMAIN … AS jsonb`), not v2's `{ data: … }` + * composite wrap. + * - **Query-term encoding** — every filter operand is the FULL storage + * envelope from `encrypt()`, serialized as jsonb text. + * + * NOT because narrowed terms fail the domain CHECK: the bundle defines a + * `public._query` companion for each storage domain, whose CHECK + * requires `NOT (VALUE ? 'c')` — i.e. it accepts exactly the no-ciphertext + * shape `encryptQuery` produces. Those domains are simply unreachable from + * here. PostgREST has no syntax to cast a filter VALUE, and an uncast literal + * is ambiguous between the `_query` and `jsonb` `@>`/`=` overloads (42725 — + * the bundle says so itself, see `cipherstash-encrypt-v3.sql`, the + * `_query_types.sql` note). The reachable overload is the `jsonb` one, whose + * body coerces its operand to the STORAGE domain, which does require `c`. + * (protect-ffi 0.29 can mint narrowed `eql_v3.query_` operands via + * `encryptQuery`, but with no way to cast a PostgREST filter value they + * stay unreachable from this adapter.) + * + * The full envelope satisfies the storage-domain CHECK by construction, and + * the operators extract the term they need (`eq_term`/`ord_term`/ + * `match_term`). + * - **`matches`, not `like`/`ilike`/`contains`** — encrypted free-text search is + * FUZZY BLOOM TOKEN MATCHING, not containment: the bundle declares `@>` on each + * match domain (`CREATE OPERATOR @> … FUNCTION = eql_v3.contains`, the SQL + * function's name), whose body is `match_term(a) @> match_term(b)` — `smallint[]` + * containment of the two bloom filters. It is order- and multiplicity- + * insensitive and one-sided (a `true` may be a false positive). PostgREST + * reaches it as `cs`. The operator is named `matches` to signal that; `contains` + * is reserved for exact (native) containment on plaintext columns. + * + * Match is tokenized + downcased, so `%` is NOT a wildcard. `like`/`ilike` on an + * encrypted column are delegated to `matches` as an APPROXIMATE compatibility + * shim (surrounding `%` stripped, internal `%`/`_` rejected, one warning) and + * pass through as real SQL LIKE on a plaintext column. + * + * Substrings DO match: the needle blooms to its own trigrams, and containment + * holds whenever every one of them is present in the stored value's bloom — + * i.e. for any substring of at least `token_length` (3) characters. Shorter + * needles bloom to nothing (`bf @> '{}'` is true for every row) and are + * rejected up front by `matchNeedleError`, not answered. + * + * Decrypted rows additionally get `Date` reconstruction from the + * encrypt-config `cast_as`, mirroring the typed v3 client. + */ +export class EncryptedQueryBuilderV3Impl< + T extends Record = Record, +> extends EncryptedQueryBuilderImpl { + private v3Table: AnyV3Table + /** JS property name → DB column name, for every encrypted column. */ + private propToDb: Record + /** DB column name → JS property name — the inverse of {@link propToDb}, used + * to expand `select('*')` back into property names. Null prototype: a DB + * column literally named `constructor` / `toString` would otherwise resolve + * to an inherited `Object.prototype` member and be emitted as a select token. */ + private dbToProp: Record + /** Built column schemas keyed by DB column name (for `cast_as`). */ + private columnSchemas: Record + /** Column builders keyed by BOTH property name and DB name. */ + private v3Columns: Record + + constructor( + tableName: string, + table: AnyV3Table, + encryptionClient: EncryptionClient, + supabaseClient: SupabaseClientLike, + allColumns: string[] | null = null, + ) { + super( + tableName, + // The base class only ever calls BuildableTable members on the schema + // (build / encryptModel plumbing); every v2-specific behaviour is + // overridden below. + table as unknown as EncryptedTable, + encryptionClient, + supabaseClient, + allColumns, + ) + + this.v3Table = table + this.propToDb = table.buildColumnKeyMap() + this.columnSchemas = table.build().columns + + this.dbToProp = Object.create(null) as Record + for (const [property, dbName] of Object.entries(this.propToDb)) { + this.dbToProp[dbName] = property + } + + assertNoPropertyDbNameCollision(tableName, this.propToDb, allColumns) + + // Null-prototype: keyed by DB column names, and `validateTransforms` reads + // it without an own-key guard — an inherited `constructor`/`toString` would + // otherwise resolve truthy for a plaintext column of that name. + this.v3Columns = Object.create(null) as Record + for (const [property, builder] of Object.entries(table.columnBuilders)) { + if (builder instanceof EncryptedV3Column) { + const col = builder as unknown as V3ColumnLike + this.v3Columns[property] = col + this.v3Columns[col.getName()] = col + } + } + + // The base class derives encrypted column names from build(), which v3 + // keys by DB name. Filters and select strings address columns by JS + // property name, so recognition must cover both. + this.encryptedColumnNames = Object.keys(this.v3Columns) + } + + // --------------------------------------------------------------------------- + // Dialect overrides + // --------------------------------------------------------------------------- + + protected override getColumnMap(): Record { + return this.v3Columns as unknown as Record + } + + /** Resolve a JS property name to its DB column name. `Object.hasOwn` guards + * the inherited-member hazard described on {@link EncryptedTable.buildColumnKeyMap}. */ + private dbNameFor(name: string): string { + return Object.hasOwn(this.propToDb, name) ? this.propToDb[name] : name + } + + protected override filterColumnName(column: string): DbName { + return this.dbNameFor(column) as DbName + } + + /** + * `ORDER BY` on an OPE-backed column is supported; on every other encrypted + * column it is rejected. + * + * A bare `ORDER BY col` IS wrong. The `*_ord` domains are + * `CREATE DOMAIN … AS jsonb`, and the bundle declares no btree operator class + * on any domain — it actively lints against one (`domain_opclass`), because an + * opclass on a domain bypasses operator resolution. So the sort resolves + * through jsonb's default `jsonb_cmp` and compares the envelope's keys in + * storage order, starting at the random ciphertext `c`. No error, and a + * stable, meaningless row order. (Measured: over 10 rows it returns + * `r00,r04,r08,r01,…` where the plaintext order is `r00..r09`.) + * + * But the correct sort key is reachable without a function call. `eql_v3.ord_term` + * returns the domain's `op` term, and OPE is order-preserving by construction: + * ordering by the term reproduces the plaintext order. PostgREST cannot emit + * `ORDER BY eql_v3.ord_term(col)`, but it CAN emit a jsonb path — + * `order=col->op.asc` — which selects exactly that term. Measured against a + * live PostgREST: `order=amount->op.asc` and `.desc` both reproduce the + * plaintext order for `integer_ord` and `text_search`, over 10 rows. + * + * So the guard is on the ordering FLAVOUR, not on encryption: + * + * - `ope` present → order by `col->op`. Every plain `_ord` domain, plus + * `text_ord` and `text_search`. + * - `ore` present → reject. The `ob` term is an array of ORE blocks whose + * comparison needs the superuser-only opclass; a jsonb-path sort over it is + * meaningless. (Such a column cannot hold data on managed Postgres at all: + * its domain CHECK raises `ore_domain_unavailable`.) + * - neither → reject. Storage-only, equality-only and match-only columns + * carry no ordering term to sort by. + * + * A column absent from {@link v3Columns} is a plaintext passthrough and orders + * normally. This runtime guard is the only protection the untyped + * (no-`schemas`) surface has. + */ + protected override validateTransforms(): void { + for (const t of this.transforms) { + if (t.kind !== 'order') continue + const column = this.v3Columns[t.column] + if (!column) continue + + const indexes = this.columnSchemas[column.getName()]?.indexes + if (indexes?.ope) continue + + const reason = indexes?.ore + ? 'its ORE ordering term (`ob`) needs the superuser-only ORE operator class, which PostgREST cannot reach through a jsonb path' + : 'it carries no ordering term to sort by' + + throw new Error( + `[supabase v3]: cannot order by encrypted column "${column.getName()}" (${column.getEqlType()}) — ${reason}. ` + + 'Order by a plaintext column, or use an OPE-backed ordering domain ' + + '(`*_ord`, `text_ord`, `text_search`), or use the EQL v3 Drizzle integration.', + ) + } + } + + /** + * Encrypted ordering columns sort by their `op` term, not by the envelope. + * + * `order=col->op` is the one ordering expression PostgREST can emit that + * reaches the OPE term. It must NOT leak into filters — those compare whole + * envelopes through the `eql_v3.*` operators — which is why this is its own + * seam rather than a change to `filterColumnName`. + * + * The canonical EQL form is `ORDER BY eql_v3.ord_term(col)`, which returns + * `eql_v3_internal.ope_cllw` — a domain over `bytea`, ordered by the native + * btree. PostgREST cannot call a function, so it orders the `op` term where it + * sits, inside the envelope. The two agree because the term is what + * `ord_term()` returns. + * + * `->` (jsonb) rather than `->>` (text) keeps the comparison on the typed + * value. Note this does NOT avoid the database collation: Postgres compares + * jsonb strings with `varstr_cmp` under the default collation, exactly as it + * does text. What makes the ordering collation-independent is the term itself + * — fixed-width lowercase hex (`[0-9a-f]`, 130 chars for `integer_ord`, 82 for + * `text_search`) — and every collation orders digits before letters and hex + * letters among themselves. `match-bloom`'s sibling assertion pins that shape. + * + * This runs at column-name-mapping time (`transformToDbSpace`), BEFORE + * `buildAndExecuteQuery` calls `validateTransforms`. For an encrypted column + * with no `ope` index it therefore returns a bare `dbName` here — a name that + * would sort by `jsonb_cmp` over the ciphertext if it reached PostgREST — but + * it never does: `validateTransforms` throws (with a domain-specific reason) + * before the query executes, so the bare name is only ever an intermediate + * value on a request that is about to be rejected. + */ + protected override orderColumnName(column: string): DbName { + const dbName = this.dbNameFor(column) + const encrypted = this.v3Columns[column] + if (!encrypted) return dbName as DbName + + return ( + this.columnSchemas[dbName]?.indexes?.ope ? `${dbName}->op` : dbName + ) as DbName + } + + /** + * Resolve a raw `.filter()` operator to the capability it exercises. Unlike + * v2, the v3 operand is always the full storage envelope, so `queryType` + * never selects a narrowing — it only tells {@link encryptCollectedTerms} + * which capability to demand of the column. Getting it wrong therefore + * produces a wrong accept/reject, not a wrong ciphertext: the base class's + * `'equality'` default rejects `.filter('bio', 'cs', …)` on a + * `public.eql_v3_text_match` column, the one query that column can answer. + * + * Unknown operators throw rather than silently defaulting to equality, which + * would encrypt a term the column may not even be able to compare. + */ + protected override queryTypeForRawOp(operator: string): QueryTypeName { + switch (operator) { + case 'cs': + return 'freeTextSearch' + case 'gt': + case 'gte': + case 'lt': + case 'lte': + return 'orderAndRange' + case 'eq': + case 'neq': + case 'in': + case 'is': + return 'equality' + default: + throw new Error( + `[supabase v3]: unsupported raw filter operator "${operator}" on an encrypted column`, + ) + } + } + + protected override buildSelectString(): DbSelect | null { + if (this.selectColumns === null) return null + return addJsonbCastsV3(this.selectColumns, this.propToDb) + } + + /** + * Expand the introspected column list (DB names) into JS property names. + * + * Load-bearing for `select('*')` on a DECLARED table that renames a column. + * `addJsonbCastsV3` only emits the `prop:db_name::jsonb` alias — the thing + * that makes PostgREST return the column under its property name — when the + * token it sees is a property name. Feeding it the raw DB name instead takes + * the unaliased `dbNames.has(...)` branch, so the row comes back keyed + * `created_at` while the declared row type promises `createdAt`, silently + * yielding `undefined` for a field TypeScript guarantees. + * + * A DB column with no encrypted builder (plaintext passthrough, and every + * synthesized column, where property == DB name) maps to itself. + */ + protected override expandAllColumns(columns: string[]): string[] { + return columns.map((dbName) => + Object.hasOwn(this.dbToProp, dbName) ? this.dbToProp[dbName] : dbName, + ) + } + + /** v3 domains are plain jsonb — send the raw payload, keyed by DB name. */ + protected override transformEncryptedMutationModel( + model: Record, + ): Record { + const out: Record = Object.create(null) + for (const [key, value] of Object.entries(model)) { + out[this.dbNameFor(key)] = value + } + return out + } + + protected override transformEncryptedMutationModels( + models: Record[], + ): Record[] { + return models.map((model) => this.transformEncryptedMutationModel(model)) + } + + /** + * Validate a term's query type against its column's declared capabilities. + * Pure validation: `encrypt`/`bulkEncrypt` never receive the query type — the + * v3 filter operand is a full storage envelope (see the class doc for why + * `encryptQuery` terms cannot be used). + */ + private assertTermQueryable(term: ScalarQueryTerm): V3ColumnLike { + const column = term.column as unknown as V3ColumnLike + const queryType = term.queryType ?? 'equality' + + if ( + queryType !== 'equality' && + queryType !== 'orderAndRange' && + queryType !== 'freeTextSearch' + ) { + throw new Error( + `[supabase v3]: query type "${queryType}" is not supported on scalar EQL v3 columns`, + ) + } + + if (!column.getQueryCapabilities()[queryType]) { + throw new Error( + `[supabase v3]: column "${column.getName()}" (${column.getEqlType()}) does not support ${queryType} queries — declare the column with a domain that carries that capability`, + ) + } + + return column + } + + private encryptionFailure(message: string, cause?: EncryptionError): never { + logger.error( + `Supabase: failed to encrypt query terms for table "${this.tableName}"`, + ) + // Most callers pass the operation's own `EncryptionError`; the contract- + // violation cases (bulk length mismatch, null envelope) have none, so + // synthesize one — a broken query encryption is still an encryption failure, + // and callers branch on `error.encryptionError` regardless. + throw new EncryptionFailedError( + `Failed to encrypt query terms: ${message}`, + cause ?? { type: EncryptionErrorTypes.EncryptionError, message }, + ) + } + + /** + * Encrypt every filter operand as a full storage envelope, serialized to jsonb + * text for the PostgREST filter value. + * + * Terms are grouped by column and each group takes ONE `bulkEncrypt` crossing. + * `in(col, [a, b, c])` collects one term per element (the list must never be + * encrypted whole), so encrypting per term spent N ZeroKMS/FFI round-trips + * where one would do. `bulkEncrypt` carries a single `{table, column}` for the + * whole payload, so the grouping is mandatory, not an optimisation: one bulk + * call over a mixed-column term array would stamp one column onto every + * plaintext. Results are scattered back onto the terms' original indices, + * which is the contract `termMap` downstream relies on. + * + * Mirrors `eql/v3/drizzle/operators.ts` `encryptOperands` — same batching + * contract, same length assertion, same fallback. Kept separate because that + * one encrypts a single-column operand list and returns `SQL[]`, while this + * must group a multi-column term array and preserve positions. + */ + protected override async encryptCollectedTerms( + terms: ScalarQueryTerm[], + ): Promise { + const groups = new Map< + V3ColumnLike, + { indices: number[]; values: ScalarQueryTerm['value'][] } + >() + terms.forEach((term, index) => { + const column = this.assertTermQueryable(term) + const group = groups.get(column) ?? { indices: [], values: [] } + group.indices.push(index) + group.values.push(term.value) + groups.set(column, group) + }) + + const bulkEncrypt = this.encryptionClient.bulkEncrypt?.bind( + this.encryptionClient, + ) + // Each term becomes the `JSON.stringify`'d storage envelope — a `string`, + // which is one arm of `EncryptedQueryResult`. PostgREST cannot cast a filter + // value to the `eql_v3.query_` twins, so v3 sends full envelopes where + // v2 sends `encryptQuery` composite literals; both are `EncryptedQueryResult`. + const results = new Array(terms.length) + + await Promise.all( + Array.from(groups, async ([column, { indices, values }]) => { + const encrypted = bulkEncrypt + ? await this.bulkEncryptGroup(bulkEncrypt, column, values) + : await this.encryptGroupPerTerm(column, values) + + encrypted.forEach((envelope, i) => { + results[indices[i]] = JSON.stringify(envelope) + }) + }), + ) + + return results + } + + /** One FFI crossing for a column's whole operand list. */ + private async bulkEncryptGroup( + bulkEncrypt: NonNullable, + column: V3ColumnLike, + values: ScalarQueryTerm['value'][], + ): Promise> { + const baseOp = bulkEncrypt( + values.map((plaintext) => ({ plaintext })) as never, + { column, table: this.v3Table } as never, + ) + const op = this.lockContext + ? baseOp.withLockContext(this.lockContext) + : baseOp + if (this.auditConfig) op.audit(this.auditConfig) + + const result = await op + if (result.failure) + this.encryptionFailure(result.failure.message, result.failure) + + // `bulkEncrypt` is position-stable, so a length mismatch means the contract + // was violated. Truncating instead would silently widen an `in` predicate + // (or narrow a `not.in`) to whatever came back. `result.data` is now + // `BulkEncryptedData` — `{ id?, data: Encrypted | null }[]` — not `unknown`. + const encrypted = result.data + if (encrypted.length !== values.length) { + this.encryptionFailure( + `bulk encryption returned ${encrypted.length} terms for ${values.length} values on column "${column.getName()}".`, + ) + } + return encrypted.map((term, i) => { + // `BulkEncryptedData` types the element as `Encrypted | null`. A `null` + // envelope here would be `JSON.stringify`'d to the literal string `"null"` + // and sent as the filter operand — silently matching whatever `"null"` + // encodes to rather than failing. A query term should never encrypt to a + // null envelope, so treat it as a contract violation, not a value. + if (term.data === null) { + this.encryptionFailure( + `bulk encryption returned a null envelope at position ${i} for column "${column.getName()}".`, + ) + } + return term.data + }) + } + + /** Fallback for a client that predates `bulkEncrypt`. */ + private async encryptGroupPerTerm( + column: V3ColumnLike, + values: ScalarQueryTerm['value'][], + ): Promise { + return Promise.all( + values.map(async (value) => { + const baseOp = this.encryptionClient.encrypt(value, { + column, + table: this.v3Table, + }) + const op = this.lockContext + ? baseOp.withLockContext(this.lockContext) + : baseOp + if (this.auditConfig) op.audit(this.auditConfig) + + const result = await op + if (result.failure) { + this.encryptionFailure(result.failure.message, result.failure) + } + return result.data + }), + ) + } + + /** Warn once per (op, column) that a `like`/`ilike` was delegated to `matches`. */ + private static readonly warnedLikeDelegation = new Set() + + /** True when `column` is one of this table's encrypted v3 columns. */ + private isEncryptedV3Column(column: string): boolean { + return Boolean(this.v3Columns[column]) + } + + /** + * `contains` on the v3 surface is EXACT containment only — native jsonb/array + * `@>` on a plaintext column. On an encrypted match/search column containment + * is not the operation (that is the fuzzy `matches`), so refuse loudly rather + * than silently emit a bloom match under a name that promises exactness. + */ + override contains(column: string, value: unknown): this { + if (this.isEncryptedV3Column(column)) { + throw new Error( + `[supabase v3]: contains() is native (exact) containment and does not apply to encrypted column "${column}". Use matches() for encrypted free-text search.`, + ) + } + return super.contains(column, value) + } + + /** + * `matches` is the encrypted free-text operator: fuzzy bloom-filter token + * matching, one-sided (may false-positive), NOT containment. It requires an + * encrypted match/search column; on a plaintext column, `contains` (native + * `@>`) is what the caller means. + */ + override matches(column: string, value: unknown): this { + if (!this.isEncryptedV3Column(column)) { + throw new Error( + `[supabase v3]: matches() is encrypted free-text search and requires an encrypted column; "${column}" is not one. Use contains() for native containment.`, + ) + } + return super.matches(column, value) + } + + /** + * `not(col, 'contains', …)` on an encrypted column would negate a fuzzy bloom + * match under the `contains` name — the exact confusion #617 removes — because + * the base `not()` path rewrites the `contains` spelling to the `cs` wire + * operator. Reject it and steer to the `matches` spelling (or the raw `cs` + * operator, which is honest about the wire op). Plaintext columns keep native + * negated containment, and every other operator is delegated unchanged. + */ + override not(column: string, operator: string, value: unknown): this { + if (operator === 'contains' && this.isEncryptedV3Column(column)) { + throw new Error( + `[supabase v3]: not("${column}", 'contains', …) does not apply to encrypted column "${column}" — that is fuzzy free-text matching, not containment. Use not("${column}", 'matches', …) or the raw 'cs' operator.`, + ) + } + return super.not(column, operator, value) + } + + /** + * `like`/`ilike` on an ENCRYPTED column are a best-effort compatibility shim, + * delegated to `matches`. EQL v3 free-text search is fuzzy bloom token + * matching, not SQL pattern matching, so the result is APPROXIMATE — matching + * is case-insensitive and one-sided (may false-positive), and anchoring is + * lost. Leading/trailing `%` are stripped; an internal `%` or any `_` cannot be + * approximated by trigram matching and throws. A plaintext column keeps real + * SQL LIKE. + */ + override like(column: string, pattern: string): this { + if (!this.isEncryptedV3Column(column)) return super.like(column, pattern) + return this.matches(column, this.likeNeedle(column, 'like', pattern)) + } + + override ilike(column: string, pattern: string): this { + if (!this.isEncryptedV3Column(column)) return super.ilike(column, pattern) + return this.matches(column, this.likeNeedle(column, 'ilike', pattern)) + } + + /** + * Reduce a SQL LIKE pattern to a fuzzy-match needle, or throw when it cannot be + * approximated. Strips surrounding `%` (prefix/suffix wildcards, which fuzzy + * matching subsumes); an internal `%` or any `_` is unapproximable. Warns once + * per (op, column) that the delegation is approximate. + */ + private likeNeedle(column: string, op: string, pattern: string): string { + const needle = pattern.replace(/^%+/, '').replace(/%+$/, '') + if (needle.includes('%') || pattern.includes('_')) { + throw new Error( + `[supabase v3]: "${op}" pattern "${pattern}" on encrypted column "${column}" has wildcards fuzzy free-text matching cannot honor (an internal "%" or any "_"). Use matches("${column}", term) with a literal search term.`, + ) + } + const key = `${op}:${column}` + if (!EncryptedQueryBuilderV3Impl.warnedLikeDelegation.has(key)) { + EncryptedQueryBuilderV3Impl.warnedLikeDelegation.add(key) + logger.warn( + `[supabase v3]: "${op}" on encrypted column "${column}" is delegated to matches() (fuzzy bloom token search). Results are APPROXIMATE — case-insensitive, one-sided (may false-positive), and wildcards/anchoring are not honored. Call matches() directly to make this explicit.`, + ) + } + return needle + } + + /** + * Encrypted `matches` goes through the bloom-filter `@>`, which the bundle + * declares on the domain as PostgREST's `cs`. The operand is the full storage + * envelope; `eql_v3.contains` (the SQL function) extracts the `bf` array from + * both sides. + * + * Emitted via `filter(col, 'cs', json)` rather than `q.contains(col, json)`: + * postgrest-js's `contains` re-serializes a non-string operand, and our + * operand is already `JSON.stringify`d. Plaintext `contains` (not encrypted) + * falls through to the base's native path. + */ + protected override applyContainsFilter( + q: SupabaseQueryBuilder, + column: DbName, + value: unknown, + wasEncrypted: boolean, + ): SupabaseQueryBuilder { + if (wasEncrypted) { + return q.filter(column, 'cs', value) + } + return super.applyContainsFilter(q, column, value, wasEncrypted) + } + + /** + * `.or()` string conditions carry raw PostgREST operators, so a free-text + * condition arrives as `cs` — not a {@link FilterOp}. Resolve it through the + * same table the raw `.filter()` path uses, so `.or('amount.cs.5')` on an + * `integer_ord` column is rejected by the capability guard rather than + * silently encrypted as an equality term. A structured `{ op: 'matches' }` + * condition maps to free-text directly. + */ + protected override queryTypeForOrOp(op: FilterOp): QueryTypeName { + if (op === 'matches') return 'freeTextSearch' + return this.queryTypeForRawOp(op) + } + + /** Rebuild `Date` values from the encrypt-config `cast_as` (date/timestamp), + * mirroring the typed v3 client's decrypt-model path. */ + protected override postprocessDecryptedRow( + row: Record, + ): Record { + // Every key an encrypted column can appear under: the keys this select + // actually produces (including caller-chosen aliases like `ts:createdAt`), + // plus the static property and DB names as a fallback for paths that record + // no select. Aliases win. Derived here from `this.selectColumns` (the row in + // hand) rather than cached from `buildSelectString`, so a reused builder can + // never postprocess a row with a previous operation's stale select map. + const keyToDb: Record = Object.assign( + Object.create(null), + this.selectColumns === null + ? undefined + : selectKeyToDbV3(this.selectColumns, this.propToDb), + ) + for (const [property, dbName] of Object.entries(this.propToDb)) { + keyToDb[property] ??= dbName + keyToDb[dbName] ??= dbName + } + + const out: Record = { ...row } + for (const [key, dbName] of Object.entries(keyToDb)) { + const castAs = this.columnSchemas[dbName]?.cast_as + if (!DATE_LIKE_CAST_SET.has(castAs as string)) continue + const value = out[key] + if (value == null || value instanceof Date) continue + if (typeof value === 'string' || typeof value === 'number') { + out[key] = new Date(value) + } + } + return out + } +} diff --git a/packages/stack/src/supabase/query-builder.ts b/packages/stack-supabase/src/query-builder.ts similarity index 51% rename from packages/stack/src/supabase/query-builder.ts rename to packages/stack-supabase/src/query-builder.ts index 5e520b0b4..715877787 100644 --- a/packages/stack/src/supabase/query-builder.ts +++ b/packages/stack-supabase/src/query-builder.ts @@ -1,24 +1,46 @@ import type { JsPlaintext } from '@cipherstash/protect-ffi' -import type { EncryptionClient } from '@/encryption' +import type { AuditConfig } from '@cipherstash/stack/adapter-kit' import { bulkModelsToEncryptedPgComposites, + logger, modelToEncryptedPgComposites, -} from '@/encryption/helpers' -import type { AuditConfig } from '@/encryption/operations/base-operation' -import type { LockContext } from '@/identity' -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' -import { EncryptedColumn } from '@/schema' -import type { BuildableQueryColumn, ScalarQueryTerm } from '@/types' -import { logger } from '@/utils/logger' +} from '@cipherstash/stack/adapter-kit' +import type { EncryptionClient } from '@cipherstash/stack/encryption' +import type { EncryptionError } from '@cipherstash/stack/errors' +import type { LockContext } from '@cipherstash/stack/identity' +import type { + EncryptedTable, + EncryptedTableColumn, +} from '@cipherstash/stack/schema' +import { EncryptedColumn } from '@cipherstash/stack/schema' +import type { + BuildableQueryColumn, + EncryptedQueryResult, + QueryTypeName, + ScalarQueryTerm, +} from '@cipherstash/stack/types' import { addJsonbCasts, + formatContainmentOperand, + formatInListOperand, getEncryptedColumnNames, + isEncryptableTerm, isEncryptedColumn, mapFilterOpToQueryType, parseOrString, rebuildOrString, } from './helpers' import type { + DbConflictList, + DbFilterString, + DbMutationOp, + DbMutationOptions, + DbName, + DbPendingOrCondition, + DbPendingOrFilter, + DbQuerySpace, + DbSelect, + DbTransformOp, EncryptedSupabaseError, EncryptedSupabaseResponse, FilterOp, @@ -51,6 +73,10 @@ export class EncryptedQueryBuilderImpl< protected encryptionClient: EncryptionClient protected supabaseClient: SupabaseClientLike protected encryptedColumnNames: string[] + /** All column names for the table (encrypted + plaintext), in ordinal order, + * used to expand `select('*')`. `null` when the caller supplied no column + * list (v2, or a v3 client that could not introspect). */ + protected allColumns: string[] | null = null // Recorded operations protected mutation: MutationOp | null = null @@ -76,12 +102,14 @@ export class EncryptedQueryBuilderImpl< schema: EncryptedTable, encryptionClient: EncryptionClient, supabaseClient: SupabaseClientLike, + allColumns: string[] | null = null, ) { this.tableName = tableName this.schema = schema this.encryptionClient = encryptionClient this.supabaseClient = supabaseClient this.encryptedColumnNames = getEncryptedColumnNames(schema) + this.allColumns = allColumns } // --------------------------------------------------------------------------- @@ -89,19 +117,34 @@ export class EncryptedQueryBuilderImpl< // --------------------------------------------------------------------------- select( - columns: string, + columns = '*', options?: { head?: boolean; count?: 'exact' | 'planned' | 'estimated' }, ): this { if (columns === '*') { - throw new Error( - "encryptedSupabase does not support select('*'). Please list columns explicitly so that encrypted columns can be cast with ::jsonb.", - ) + if (this.allColumns === null || this.allColumns.length === 0) { + throw new Error( + "encryptedSupabase does not support select('*'). Please list columns explicitly so that encrypted columns can be cast with ::jsonb.", + ) + } + this.selectColumns = this.expandAllColumns(this.allColumns).join(', ') + } else { + this.selectColumns = columns } - this.selectColumns = columns this.selectOptions = options return this } + /** + * Turn the introspected column list (DB names) into select tokens. The base + * returns them unchanged — v2 never supplies a column list, so this is dead + * for v2. The v3 dialect overrides it to emit JS property names, which is + * what makes `addJsonbCastsV3` alias a renamed column back to its property + * (`createdAt:created_at::jsonb`) rather than returning it under its DB name. + */ + protected expandAllColumns(columns: string[]): string[] { + return columns + } + insert( data: Partial | Partial[], options?: { @@ -196,6 +239,22 @@ export class EncryptedQueryBuilderImpl< return this } + contains(column: string, value: unknown): this { + this.filters.push({ op: 'contains', column, value }) + return this + } + + /** + * Encrypted free-text token match (v3 encrypted columns). Emits the same + * `cs`/`@>` wire operator as `contains`, but on a match-indexed encrypted + * column it is fuzzy bloom-filter token matching, not containment — see the v3 + * builder. The v3 dialect encrypts the operand as a free-text query term. + */ + matches(column: string, value: unknown): this { + this.filters.push({ op: 'matches', column, value }) + return this + } + is(column: string, value: null | boolean): this { this.filters.push({ op: 'is', column, value }) return this @@ -350,17 +409,21 @@ export class EncryptedQueryBuilderImpl< // 2. Build select string with ::jsonb casts const selectString = this.buildSelectString() - // 3. Batch-encrypt filter values - const encryptedFilters = await this.encryptFilterValues() + // 3. Translate every recorded column name into DB-space, once. + const dbSpace = this.toDbSpace() + + // 4. Batch-encrypt filter values + const encryptedFilters = await this.encryptFilterValues(dbSpace) - // 4. Build and execute real Supabase query + // 5. Build and execute real Supabase query const result = await this.buildAndExecuteQuery( encryptedMutation, selectString, encryptedFilters, + dbSpace, ) - // 5. Decrypt results + // 6. Decrypt results return await this.decryptResults(result) } catch (err) { const message = err instanceof Error ? err.message : String(err) @@ -368,9 +431,17 @@ export class EncryptedQueryBuilderImpl< `Supabase encrypted query failed on table "${this.tableName}": ${message}`, ) + // A failure inside any of the encrypt/decrypt steps above is thrown as an + // `EncryptionFailedError` wrapping the operation's `EncryptionError` (or, in + // the v3 dialect, a synthesized one for its contract-violation cases). + // Thread it through so callers can branch on `error.encryptionError`; a plain + // PostgREST/API error is not an `EncryptionFailedError` and leaves it unset. const error: EncryptedSupabaseError = { message, - encryptionError: undefined, + encryptionError: + err instanceof EncryptionFailedError + ? err.encryptionError + : undefined, } if (this.shouldThrowOnError) { @@ -468,7 +539,7 @@ export class EncryptedQueryBuilderImpl< // Step 2: Build select string with casts // --------------------------------------------------------------------------- - protected buildSelectString(): string | null { + protected buildSelectString(): DbSelect | null { if (this.selectColumns === null) return null return addJsonbCasts(this.selectColumns, this.encryptedColumnNames) } @@ -477,142 +548,204 @@ export class EncryptedQueryBuilderImpl< // Step 3: Encrypt filter values // --------------------------------------------------------------------------- - protected async encryptFilterValues(): Promise { + protected async encryptFilterValues( + dbSpace: DbQuerySpace, + ): Promise { // Collect all terms that need encryption const terms: ScalarQueryTerm[] = [] const termMap: TermMapping[] = [] const tableColumns = this.getColumnMap() + const pushTerm = ( + value: JsPlaintext, + column: ScalarQueryTerm['column'], + queryType: QueryTypeName, + mapping: TermMapping, + ) => { + terms.push({ + value, + column, + table: this.schema, + queryType, + returnType: 'composite-literal', + }) + termMap.push(mapping) + } + + /** + * Collect one term per element of an `in`-list operand. + * + * Element-wise is the only correct encoding: encrypting the array as ONE + * value collapses `(a,b)` into a single ciphertext that matches nothing. A + * null element is SQL NULL and passes through unencrypted; the applier + * restores it by index, which is why the mapping carries `inIndex`. + * + * Shared by the regular-`in`, `not(…,'in',…)` and or-condition paths. They + * drifted apart once already — the `not` path went unfixed while the other + * two encrypted element-wise — so they are kept in lockstep here rather than + * spelled out three times. + */ + const collectInListTerms = ( + op: FilterOp, + values: readonly unknown[], + column: ScalarQueryTerm['column'], + queryType: QueryTypeName, + mappingFor: (inIndex: number) => TermMapping, + ) => { + for (let j = 0; j < values.length; j++) { + if (!isEncryptableTerm(op, values[j])) continue + pushTerm(values[j] as JsPlaintext, column, queryType, mappingFor(j)) + } + } + // Regular filters - for (let i = 0; i < this.filters.length; i++) { - const f = this.filters[i] + for (let i = 0; i < dbSpace.filters.length; i++) { + const f = dbSpace.filters[i] if (!isEncryptedColumn(f.column, this.encryptedColumnNames)) continue const column = tableColumns[f.column] if (!column) continue if (f.op === 'in' && Array.isArray(f.value)) { - // For `in` filters, encrypt each value separately - for (let j = 0; j < f.value.length; j++) { - terms.push({ - value: f.value[j] as JsPlaintext, - column, - table: this.schema, - queryType: mapFilterOpToQueryType(f.op), - returnType: 'composite-literal', - }) - termMap.push({ source: 'filter', filterIndex: i, inIndex: j }) - } - } else if (f.op === 'is') { - } else { - terms.push({ - value: f.value as JsPlaintext, + collectInListTerms( + f.op, + f.value, column, - table: this.schema, - queryType: mapFilterOpToQueryType(f.op), - returnType: 'composite-literal', + mapFilterOpToQueryType(f.op), + (inIndex) => ({ source: 'filter', filterIndex: i, inIndex }), + ) + } else if (!isEncryptableTerm(f.op, f.value)) { + // `is` predicate or null operand — forwarded unencrypted. + } else { + pushTerm(f.value as JsPlaintext, column, mapFilterOpToQueryType(f.op), { + source: 'filter', + filterIndex: i, }) - termMap.push({ source: 'filter', filterIndex: i }) } } // Match filters - for (let i = 0; i < this.matchFilters.length; i++) { - const mf = this.matchFilters[i] - for (const [colName, value] of Object.entries(mf.query)) { + for (let i = 0; i < dbSpace.matchFilters.length; i++) { + const mf = dbSpace.matchFilters[i] + for (const { column: colName, value } of mf.entries) { if (!isEncryptedColumn(colName, this.encryptedColumnNames)) continue + // `match` carries no operator; equality is implied. + if (!isEncryptableTerm('eq', value)) continue const column = tableColumns[colName] if (!column) continue - terms.push({ - value: value as JsPlaintext, - column, - table: this.schema, - queryType: 'equality', - returnType: 'composite-literal', + pushTerm(value as JsPlaintext, column, 'equality', { + source: 'match', + matchIndex: i, + column: colName, }) - termMap.push({ source: 'match', matchIndex: i, column: colName }) } } // Not filters - for (let i = 0; i < this.notFilters.length; i++) { - const nf = this.notFilters[i] + for (let i = 0; i < dbSpace.notFilters.length; i++) { + const nf = dbSpace.notFilters[i] if (!isEncryptedColumn(nf.column, this.encryptedColumnNames)) continue + if (!isEncryptableTerm(nf.op, nf.value)) continue const column = tableColumns[nf.column] if (!column) continue - terms.push({ - value: nf.value as JsPlaintext, - column, - table: this.schema, - queryType: mapFilterOpToQueryType(nf.op), - returnType: 'composite-literal', + if (nf.op === 'in') { + // A PostgREST list literal (`'(a,b)'`) cannot be encrypted element-wise, + // and encrypting it whole matches nothing. Refuse it rather than emit a + // filter that silently returns no rows. + if (!Array.isArray(nf.value)) { + throw new Error( + `not("${nf.column}", "in", …) on an encrypted column requires an array of values, ` + + `not a PostgREST list literal — each element must be encrypted separately`, + ) + } + collectInListTerms( + nf.op, + nf.value, + column, + mapFilterOpToQueryType(nf.op), + (inIndex) => ({ source: 'not', notIndex: i, inIndex }), + ) + continue + } + + pushTerm(nf.value as JsPlaintext, column, mapFilterOpToQueryType(nf.op), { + source: 'not', + notIndex: i, }) - termMap.push({ source: 'not', notIndex: i }) } - // Or filters (string form parsed into conditions) - for (let i = 0; i < this.orFilters.length; i++) { - const of_ = this.orFilters[i] - if (of_.kind === 'string') { - const parsed = parseOrString(of_.value) - for (let j = 0; j < parsed.length; j++) { - const cond = parsed[j] - if (!isEncryptedColumn(cond.column, this.encryptedColumnNames)) - continue - const column = tableColumns[cond.column] - if (!column) continue - - terms.push({ - value: cond.value as JsPlaintext, - column, - table: this.schema, - queryType: mapFilterOpToQueryType(cond.op), - returnType: 'composite-literal', - }) - termMap.push({ source: 'or-string', orIndex: i, conditionIndex: j }) - } - } else { - for (let j = 0; j < of_.conditions.length; j++) { - const cond = of_.conditions[j] - if (!isEncryptedColumn(cond.column, this.encryptedColumnNames)) - continue - const column = tableColumns[cond.column] - if (!column) continue - - terms.push({ - value: cond.value as JsPlaintext, - column, - table: this.schema, - queryType: mapFilterOpToQueryType(cond.op), - returnType: 'composite-literal', - }) - termMap.push({ - source: 'or-structured', - orIndex: i, - conditionIndex: j, - }) + // Or filters — conditions were parsed once, in `toDbSpace`. The string and + // structured forms differ only in their `source` tag; the encryption rules, + // including the `in`-list split below, are identical. + for (let i = 0; i < dbSpace.orFilters.length; i++) { + const of_ = dbSpace.orFilters[i] + const source = of_.kind === 'string' ? 'or-string' : 'or-structured' + + for (let j = 0; j < of_.conditions.length; j++) { + const cond = of_.conditions[j] + if (!isEncryptedColumn(cond.column, this.encryptedColumnNames)) continue + const column = tableColumns[cond.column] + if (!column) continue + + // `queryTypeForOrOp`, not `mapFilterOpToQueryType`: an or-condition may + // carry a raw PostgREST operator (`cs`), which is not a `FilterOp`. + const queryType = this.queryTypeForOrOp(cond.op) + const mappingFor = (inIndex?: number): TermMapping => ({ + source, + orIndex: i, + conditionIndex: j, + inIndex, + }) + + if (cond.op === 'in' && Array.isArray(cond.value)) { + collectInListTerms(cond.op, cond.value, column, queryType, mappingFor) + continue } + + if (!isEncryptableTerm(cond.op, cond.value)) continue + pushTerm(cond.value as JsPlaintext, column, queryType, mappingFor()) } } // Raw filters - for (let i = 0; i < this.rawFilters.length; i++) { - const rf = this.rawFilters[i] + for (let i = 0; i < dbSpace.rawFilters.length; i++) { + const rf = dbSpace.rawFilters[i] if (!isEncryptedColumn(rf.column, this.encryptedColumnNames)) continue const column = tableColumns[rf.column] if (!column) continue - terms.push({ - value: rf.value as JsPlaintext, + if (rf.operator === 'in') { + // Same contract as the `not(…, 'in', …)` path: a PostgREST list literal + // (`'("a","b")'`) cannot be encrypted element-wise, and encrypting it + // whole matches nothing. Refuse it rather than emit a filter that + // silently returns no rows. + if (!Array.isArray(rf.value)) { + throw new Error( + `filter("${rf.column}", "in", …) on an encrypted column requires an array of values, ` + + `not a PostgREST list literal — each element must be encrypted separately`, + ) + } + collectInListTerms( + 'in', + rf.value, + column, + this.queryTypeForRawOp(rf.operator), + (inIndex) => ({ source: 'raw', rawIndex: i, inIndex }), + ) + continue + } + + if (!isEncryptableTerm(rf.operator, rf.value)) continue + + pushTerm( + rf.value as JsPlaintext, column, - table: this.schema, - queryType: 'equality', - returnType: 'composite-literal', - }) - termMap.push({ source: 'raw', rawIndex: i }) + this.queryTypeForRawOp(rf.operator), + { source: 'raw', rawIndex: i }, + ) } if (terms.length === 0) { @@ -632,7 +765,7 @@ export class EncryptedQueryBuilderImpl< */ protected async encryptCollectedTerms( terms: ScalarQueryTerm[], - ): Promise { + ): Promise { // Batch encrypt all terms in one call const baseOp = this.encryptionClient.encryptQuery(terms) const op = this.lockContext @@ -655,6 +788,120 @@ export class EncryptedQueryBuilderImpl< return result.data } + // --------------------------------------------------------------------------- + // Phase boundary: property-space -> DB-space + // --------------------------------------------------------------------------- + + /** + * Translate every recorded column name from JS property space into DB space, + * once. Downstream (`encryptFilterValues`, `applyFilters`, + * `buildAndExecuteQuery`) consumes only the branded result, so a column can + * no longer reach PostgREST untranslated — that is a compile error. + * + * Total: `filterColumnName`, `parseOrString`, and `resolveMutationOptions` + * never throw, so this introduces no new early-throw point and cannot perturb + * the order in which capability errors surface. + * + * Safe to run BEFORE encryption: `getColumnMap()`/`encryptedColumnNames` are + * keyed by both property and DB name in v3 (and property == DB name in v2), + * so column lookup resolves identically either side of the translation, and + * `tableColumns[prop]` is the very same builder object as `tableColumns[db]`. + */ + protected toDbSpace(): DbQuerySpace { + return { + filters: this.filters.map((f) => ({ + ...f, + column: this.filterColumnName(f.column), + })), + matchFilters: this.matchFilters.map((mf) => ({ + entries: Object.entries(mf.query).map(([column, value]) => ({ + column: this.filterColumnName(column), + value, + })), + })), + notFilters: this.notFilters.map((nf) => ({ + ...nf, + column: this.filterColumnName(nf.column), + })), + rawFilters: this.rawFilters.map((rf) => ({ + ...rf, + column: this.filterColumnName(rf.column), + })), + orFilters: this.orFilters.map((of_) => this.orFilterToDbSpace(of_)), + transforms: this.transforms.map((t) => this.transformToDbSpace(t)), + mutation: this.mutation ? this.mutationToDbSpace(this.mutation) : null, + } + } + + /** Column names only. Which conditions were encrypted is never decided here: + * it stays derived at apply time from the substitution maps, so this pass + * never has to agree with the encryption predicate. The operator token is + * settled later still, in `rebuildOrString`, where `contains` becomes `cs` + * for encrypted and plaintext conditions alike. */ + private orFilterToDbSpace(of_: PendingOrFilter): DbPendingOrFilter { + const toDbCondition = (c: PendingOrCondition): DbPendingOrCondition => ({ + ...c, + column: this.filterColumnName(c.column), + }) + + if (of_.kind === 'string') { + return { + kind: 'string', + original: of_.value, + conditions: parseOrString(of_.value).map(toDbCondition), + referencedTable: of_.referencedTable, + } + } + return { kind: 'structured', conditions: of_.conditions.map(toDbCondition) } + } + + /** + * The column expression `order()` sends to PostgREST. Its own seam, separate + * from {@link filterColumnName}: v3 orders an encrypted column by a jsonb path + * into its ordering term, which must not leak into filters. + */ + protected orderColumnName(column: string): DbName { + return this.filterColumnName(column) + } + + private transformToDbSpace(t: TransformOp): DbTransformOp { + switch (t.kind) { + case 'order': + return { ...t, column: this.orderColumnName(t.column) } + // `returns` is in the union but never pushed (`returns()` is a cast). + case 'limit': + case 'range': + case 'single': + case 'maybeSingle': + case 'csv': + case 'abortSignal': + case 'throwOnError': + case 'returns': + return t + default: { + const exhaustive: never = t + return exhaustive + } + } + } + + private mutationToDbSpace(m: MutationOp): DbMutationOp { + switch (m.kind) { + case 'insert': + case 'upsert': + // `resolveMutationOptions` returns the SAME reference when no column + // needed renaming, which v2 relies on. + return { ...m, options: this.resolveMutationOptions(m.options) } + case 'update': + case 'delete': + return m // options carry no column names + default: { + const exhaustive: never = m + return exhaustive + } + } + } + // --------------------------------------------------------------------------- // Step 4: Build and execute real Supabase query // --------------------------------------------------------------------------- @@ -664,25 +911,28 @@ export class EncryptedQueryBuilderImpl< | Record | Record[] | null, - selectString: string | null, + selectString: DbSelect | null, encryptedFilters: EncryptedFilterState, + dbSpace: DbQuerySpace, ): Promise { + this.validateTransforms() + let query: SupabaseQueryBuilder = this.supabaseClient.from(this.tableName) - // Apply mutation - if (this.mutation) { - switch (this.mutation.kind) { + // Apply mutation — options already resolved to DB-space by `toDbSpace`. + if (dbSpace.mutation) { + switch (dbSpace.mutation.kind) { case 'insert': - query = query.insert(encryptedMutation!, this.mutation.options) + query = query.insert(encryptedMutation!, dbSpace.mutation.options) break case 'update': - query = query.update(encryptedMutation!, this.mutation.options) + query = query.update(encryptedMutation!, dbSpace.mutation.options) break case 'upsert': - query = query.upsert(encryptedMutation!, this.mutation.options) + query = query.upsert(encryptedMutation!, dbSpace.mutation.options) break case 'delete': - query = query.delete(this.mutation.options) + query = query.delete(dbSpace.mutation.options) break } } @@ -692,14 +942,14 @@ export class EncryptedQueryBuilderImpl< query = query.select(selectString, this.selectOptions) } else if (!this.mutation) { // Default select without explicit columns - shouldn't happen but fallback - query = query.select('*', this.selectOptions) + query = query.select('*' as DbSelect, this.selectOptions) } // Apply resolved filters - query = this.applyFilters(query, encryptedFilters) + query = this.applyFilters(query, encryptedFilters, dbSpace) - // Apply transforms - for (const t of this.transforms) { + // Apply transforms — column names already in DB-space. + for (const t of dbSpace.transforms) { switch (t.kind) { case 'order': query = query.order(t.column, t.options) @@ -739,6 +989,7 @@ export class EncryptedQueryBuilderImpl< protected applyFilters( query: SupabaseQueryBuilder, encryptedFilters: EncryptedFilterState, + dbSpace: DbQuerySpace, ): SupabaseQueryBuilder { let q = query @@ -747,7 +998,9 @@ export class EncryptedQueryBuilderImpl< const filterInMap = new Map() // "filterIndex:inIndex" -> value const matchValueMap = new Map() // "matchIndex:column" -> value const notValueMap = new Map() + const notInMap = new Map() // "notIndex:inIndex" -> value const rawValueMap = new Map() + const rawInMap = new Map() // "rawIndex:inIndex" -> value const orStringConditionMap = new Map() // "orIndex:condIndex" -> value const orStructuredConditionMap = new Map() @@ -770,29 +1023,33 @@ export class EncryptedQueryBuilderImpl< matchValueMap.set(`${mapping.matchIndex}:${mapping.column}`, encValue) break case 'not': - notValueMap.set(mapping.notIndex, encValue) + if (mapping.inIndex !== undefined) { + notInMap.set(`${mapping.notIndex}:${mapping.inIndex}`, encValue) + } else { + notValueMap.set(mapping.notIndex, encValue) + } break case 'raw': - rawValueMap.set(mapping.rawIndex, encValue) + if (mapping.inIndex !== undefined) { + rawInMap.set(`${mapping.rawIndex}:${mapping.inIndex}`, encValue) + } else { + rawValueMap.set(mapping.rawIndex, encValue) + } break + // `inIndex` widens the key to address one element of an `in` list, so a + // whole-condition value and a per-element value never collide. case 'or-string': - orStringConditionMap.set( - `${mapping.orIndex}:${mapping.conditionIndex}`, - encValue, - ) + orStringConditionMap.set(orKey(mapping), encValue) break case 'or-structured': - orStructuredConditionMap.set( - `${mapping.orIndex}:${mapping.conditionIndex}`, - encValue, - ) + orStructuredConditionMap.set(orKey(mapping), encValue) break } } // Apply regular filters - for (let i = 0; i < this.filters.length; i++) { - const f = this.filters[i] + for (let i = 0; i < dbSpace.filters.length; i++) { + const f = dbSpace.filters[i] let value = f.value if (filterValueMap.has(i)) { @@ -805,7 +1062,7 @@ export class EncryptedQueryBuilderImpl< }) } - const column = this.filterColumnName(f.column) + const column = f.column const wasEncrypted = filterValueMap.has(i) switch (f.op) { @@ -831,23 +1088,38 @@ export class EncryptedQueryBuilderImpl< case 'ilike': q = this.applyPatternFilter(q, column, f.op, value, wasEncrypted) break + // `matches` (encrypted free-text) and `contains` (plaintext / encrypted + // JSON) share the `cs`/`@>` wire operator; the operand encoding is the + // same, so both emit through the one containment applier. + case 'contains': + case 'matches': + q = this.applyContainsFilter(q, column, value, wasEncrypted) + break case 'is': q = q.is(column, value) break case 'in': - q = q.in(column, value as unknown[]) + // `wasEncrypted` above is false for in-lists: their ciphertexts land + // in `filterInMap`, keyed per element. + q = this.applyInFilter( + q, + column, + value as unknown[], + Array.isArray(f.value) && + f.value.some((_, j) => filterInMap.has(`${i}:${j}`)), + ) break } } // Apply match filters - for (let i = 0; i < this.matchFilters.length; i++) { - const mf = this.matchFilters[i] + for (let i = 0; i < dbSpace.matchFilters.length; i++) { + const mf = dbSpace.matchFilters[i] const resolvedQuery: Record = {} - for (const [colName, originalValue] of Object.entries(mf.query)) { + for (const { column: colName, value: originalValue } of mf.entries) { const key = `${i}:${colName}` - resolvedQuery[this.filterColumnName(colName)] = matchValueMap.has(key) + resolvedQuery[colName] = matchValueMap.has(key) ? matchValueMap.get(key) : originalValue } @@ -856,70 +1128,105 @@ export class EncryptedQueryBuilderImpl< } // Apply not filters - for (let i = 0; i < this.notFilters.length; i++) { - const nf = this.notFilters[i] + for (let i = 0; i < dbSpace.notFilters.length; i++) { + const nf = dbSpace.notFilters[i] + + if (nf.op === 'in' && Array.isArray(nf.value)) { + const values = nf.value.map((v, j) => + notInMap.has(`${i}:${j}`) ? notInMap.get(`${i}:${j}`) : v, + ) + q = q.not(nf.column, 'in', formatInListOperand(values)) + continue + } + const wasEncrypted = notValueMap.has(i) const value = wasEncrypted ? notValueMap.get(i) : nf.value - q = q.not( - this.filterColumnName(nf.column), - this.notFilterOperator(nf.op, wasEncrypted), - value, - ) + + // `contains` is a supabase-js METHOD name, not a PostgREST operator, and + // `q.not()` interpolates its operand with `String(value)` — so an array + // arrives brace-less and an object as `[object Object]`. Build the + // containment literal ourselves and emit the `cs` token, exactly as the + // `.or()` path does. A scalar (including the encrypted envelope, already + // serialized) yields `null` and is forwarded untouched. + if (nf.op === 'contains' || nf.op === 'matches') { + const literal = formatContainmentOperand(value) + q = q.not(nf.column, 'cs', literal ?? value) + continue + } + + q = q.not(nf.column, this.notFilterOperator(nf.op, wasEncrypted), value) } // Apply or filters - for (let i = 0; i < this.orFilters.length; i++) { - const of_ = this.orFilters[i] + for (let i = 0; i < dbSpace.orFilters.length; i++) { + const of_ = dbSpace.orFilters[i] if (of_.kind === 'string') { - const parsed = parseOrString(of_.value) - const encryptedIndexes = new Set() + // Already parsed (once) and translated by `toDbSpace`. + const parsed = [...of_.conditions] for (let j = 0; j < parsed.length; j++) { - const key = `${i}:${j}` - if (orStringConditionMap.has(key)) { - parsed[j] = { ...parsed[j], value: orStringConditionMap.get(key) } - encryptedIndexes.add(j) + const sub = substituteOrValue(orStringConditionMap, i, j, parsed[j]) + if (sub) { + parsed[j] = { ...parsed[j], value: sub.value } } } - if (encryptedIndexes.size > 0) { - q = q.or( - rebuildOrString( - this.transformOrConditions(parsed, encryptedIndexes), - ), - { - referencedTable: of_.referencedTable, - }, - ) + // Rebuild whenever a condition REFERENCES an encrypted column — not + // merely when a value was encrypted. An `is`/null operand on an + // encrypted column encrypts nothing, so keying on "was a value + // substituted" would send that condition down the verbatim path below + // and forward the caller's JS property name to a DB that only knows the + // column's real name. `toDbSpace` has already translated `parsed`. + const referencesEncrypted = parsed.some((c) => + isEncryptedColumn(c.column, this.encryptedColumnNames), + ) + + if (referencesEncrypted) { + q = q.or(rebuildOrString(parsed), { + referencedTable: of_.referencedTable, + }) } else { - q = q.or(of_.value, { referencedTable: of_.referencedTable }) + // Every condition names a plaintext column, whose property name IS + // its DB name — nothing to map. Forward the caller's ORIGINAL string + // byte-for-byte: v2 relies on this for nested `and()` and quoted + // values that `parseOrString`/`rebuildOrString` cannot round-trip. + q = q.or(of_.original as DbFilterString, { + referencedTable: of_.referencedTable, + }) } } else { // Structured: convert to string - const encryptedIndexes = new Set() const conditions = of_.conditions.map((cond, j) => { - const key = `${i}:${j}` - if (orStructuredConditionMap.has(key)) { - encryptedIndexes.add(j) - return { ...cond, value: orStructuredConditionMap.get(key) } - } - return cond + const sub = substituteOrValue(orStructuredConditionMap, i, j, cond) + return sub ? { ...cond, value: sub.value } : cond }) - q = q.or( - rebuildOrString( - this.transformOrConditions(conditions, encryptedIndexes), - ), - ) + q = q.or(rebuildOrString(conditions)) } } // Apply raw filters - for (let i = 0; i < this.rawFilters.length; i++) { - const rf = this.rawFilters[i] + for (let i = 0; i < dbSpace.rawFilters.length; i++) { + const rf = dbSpace.rawFilters[i] + + // An encrypted `in` list was encrypted element-wise; reassemble it into + // the quoted PostgREST list literal, exactly as the `not` path does. A + // plaintext column keeps its operand untouched. + if ( + rf.operator === 'in' && + Array.isArray(rf.value) && + isEncryptedColumn(rf.column, this.encryptedColumnNames) + ) { + const values = rf.value.map((v, j) => + rawInMap.has(`${i}:${j}`) ? rawInMap.get(`${i}:${j}`) : v, + ) + q = q.filter(rf.column, rf.operator, formatInListOperand(values)) + continue + } + const value = rawValueMap.has(i) ? rawValueMap.get(i) : rf.value - q = q.filter(this.filterColumnName(rf.column), rf.operator, value) + q = q.filter(rf.column, rf.operator, value) } return q @@ -935,9 +1242,78 @@ export class EncryptedQueryBuilderImpl< * Map a filter's column name to the DB column name PostgREST must see. * v2 schemas key columns by their DB name already, so this is the identity; * the v3 dialect resolves a JS property name to its DB name. + * + * This is the ONLY place a {@link DbName} is minted. The + * {@link SupabaseQueryBuilder} seam accepts nothing else, so every column + * name reaching PostgREST must pass through here. + */ + protected filterColumnName(column: string): DbName { + return column as DbName + } + + /** + * Resolve the column names carried by a mutation's options. `onConflict` is a + * comma-separated column list, so it needs the same property→DB mapping as a + * filter. Returns the original object when nothing changed, so v2 — where + * {@link filterColumnName} is the identity — passes the caller's reference on + * untouched. + */ + protected resolveMutationOptions< + O extends { onConflict?: string } | undefined, + >(options: O): DbMutationOptions | undefined { + if (!options?.onConflict) return options as DbMutationOptions | undefined + const mapped = options.onConflict + .split(',') + .map((column) => this.filterColumnName(column.trim())) + .join(',') as DbConflictList + return ( + mapped === options.onConflict + ? options + : { ...options, onConflict: mapped } + ) as DbMutationOptions + } + + /** + * Validate the accumulated transforms before the query is built. Called from + * inside {@link execute}'s try, so a throw surfaces as a `status: 500` error + * result (or rethrows under `throwOnError`), matching the filter-path + * capability guard. v2 imposes no constraints. + */ + protected validateTransforms(): void {} + + /** + * The CipherStash query type to encrypt a raw `.filter(column, operator, …)` + * term under. `operator` is an arbitrary PostgREST operator string, not a + * {@link FilterOp}, so it cannot go through `mapFilterOpToQueryType`. + * + * v2 encrypts every raw filter as an equality term. That is wrong — a raw + * `.filter('amount', 'gte', …)` wants an ORE term — but in v2 `queryType` + * selects the `encryptQuery` narrowing, so correcting it changes the + * ciphertext on the wire. Preserved verbatim here and tracked separately; + * the v3 dialect, where `queryType` is only a capability gate, overrides it. */ - protected filterColumnName(column: string): string { - return column + protected queryTypeForRawOp(_operator: string): QueryTypeName { + return 'equality' + } + + /** + * Apply an `in` filter. + * + * A plaintext list goes to postgrest-js's `in()`, which quotes elements that + * contain `,()`. An ENCRYPTED list cannot: every element is a + * `JSON.stringify`d envelope, and `in()` wraps it in `"…"` without escaping + * the quotes inside it, so PostgREST terminates the value at the envelope's + * first `"`. Emit the operand ourselves and hand it to `filter()`, which + * forwards it verbatim. + */ + protected applyInFilter( + q: SupabaseQueryBuilder, + column: DbName, + values: unknown[], + wasEncrypted: boolean, + ): SupabaseQueryBuilder { + if (!wasEncrypted) return q.in(column, values) + return q.filter(column, 'in', formatInListOperand(values)) } /** @@ -948,7 +1324,7 @@ export class EncryptedQueryBuilderImpl< */ protected applyPatternFilter( q: SupabaseQueryBuilder, - column: string, + column: DbName, op: 'like' | 'ilike', value: unknown, _wasEncrypted: boolean, @@ -959,23 +1335,43 @@ export class EncryptedQueryBuilderImpl< } /** - * The PostgREST operator to use for a `.not()` filter. The v3 dialect maps - * `like`/`ilike` on encrypted columns to `cs` (see applyPatternFilter). + * Apply a `contains` filter. On a plaintext column this is PostgREST's native + * jsonb/array containment. The v3 dialect overrides it for encrypted columns, + * where `cs` resolves to the `@>` operator the EQL bundle declares on the + * domain, backed by `eql_v3.contains` (bloom-filter containment). + * + * A structured operand is serialized here rather than by postgrest-js, which + * joins array elements on `,` without quoting them — so `['with,comma']` would + * reach Postgres as two elements. Scalars keep the native path. */ - protected notFilterOperator(op: FilterOp, _wasEncrypted: boolean): string { - return op + protected applyContainsFilter( + q: SupabaseQueryBuilder, + column: DbName, + value: unknown, + _wasEncrypted: boolean, + ): SupabaseQueryBuilder { + const literal = formatContainmentOperand(value) + return literal !== null + ? q.filter(column, 'cs', literal) + : q.contains(column, value) } /** - * Transform `.or()` conditions before the or-string is rebuilt. The v3 - * dialect maps property names to DB names and `like`/`ilike` on encrypted - * conditions to `cs`. + * The CipherStash query type for an `.or()` condition's operator on an + * encrypted column. String-form conditions carry raw PostgREST operators + * (`cs`), which are not {@link FilterOp}s; the v3 dialect maps those. */ - protected transformOrConditions( - conditions: PendingOrCondition[], - _encryptedIndexes: Set, - ): PendingOrCondition[] { - return conditions + protected queryTypeForOrOp(op: FilterOp): QueryTypeName { + return mapFilterOpToQueryType(op) + } + + /** + * The PostgREST operator to use for a `.not()` filter. Every {@link FilterOp} + * except `contains` spells the same as its PostgREST operator; `contains` is + * handled before this is reached, because it also needs its operand rewritten. + */ + protected notFilterOperator(op: FilterOp, _wasEncrypted: boolean): string { + return op } /** @@ -1148,16 +1544,71 @@ export class EncryptedQueryBuilderImpl< type TermMapping = | { source: 'filter'; filterIndex: number; inIndex?: number } | { source: 'match'; matchIndex: number; column: string } - | { source: 'not'; notIndex: number } - | { source: 'raw'; rawIndex: number } - | { source: 'or-string'; orIndex: number; conditionIndex: number } - | { source: 'or-structured'; orIndex: number; conditionIndex: number } + | { source: 'not'; notIndex: number; inIndex?: number } + | { source: 'raw'; rawIndex: number; inIndex?: number } + | { + source: 'or-string' + orIndex: number + conditionIndex: number + inIndex?: number + } + | { + source: 'or-structured' + orIndex: number + conditionIndex: number + inIndex?: number + } type EncryptedFilterState = { - encryptedValues: unknown[] + // `EncryptedQueryResult[]`, not `unknown[]` — `encryptCollectedTerms` returns + // that type, and typing the field to match is what lets the restored envelope + // type reach the use site (`encryptedValues[i]`) instead of widening back to + // `unknown` at this boundary. + encryptedValues: EncryptedQueryResult[] termMap: TermMapping[] } +/** Key an `.or()` condition, or one element of its `in` list. */ +function orKey(mapping: { + orIndex: number + conditionIndex: number + inIndex?: number +}): string { + const base = `${mapping.orIndex}:${mapping.conditionIndex}` + return mapping.inIndex === undefined ? base : `${base}:${mapping.inIndex}` +} + +/** + * Substitute encrypted operands back into one `.or()` condition, returning + * `undefined` when nothing was encrypted for it. + * + * An `in` list is reconstructed element-by-element so `formatOrValue` re-emits + * the `(a,b)` list form. Substituting the array as a single value would collapse + * it to one ciphertext that matches nothing. + */ +function substituteOrValue( + map: Map, + orIndex: number, + conditionIndex: number, + cond: { op: FilterOp; value: unknown }, +): { value: unknown } | undefined { + const whole = orKey({ orIndex, conditionIndex }) + if (map.has(whole)) return { value: map.get(whole) } + + if (cond.op === 'in' && Array.isArray(cond.value)) { + let substituted = false + const value = cond.value.map((element, inIndex) => { + const key = orKey({ orIndex, conditionIndex, inIndex }) + if (!map.has(key)) return element + substituted = true + return map.get(key) + }) + if (substituted) return { value } + } + + return undefined +} + type RawSupabaseResult = { data: unknown error: { @@ -1172,9 +1623,9 @@ type RawSupabaseResult = { } export class EncryptionFailedError extends Error { - public encryptionError: unknown + public encryptionError: EncryptionError - constructor(message: string, encryptionError: unknown) { + constructor(message: string, encryptionError: EncryptionError) { super(message) this.name = 'EncryptionFailedError' this.encryptionError = encryptionError diff --git a/packages/stack-supabase/src/schema-builder.ts b/packages/stack-supabase/src/schema-builder.ts new file mode 100644 index 000000000..ff6dec8b2 --- /dev/null +++ b/packages/stack-supabase/src/schema-builder.ts @@ -0,0 +1,94 @@ +import type { AnyEncryptedV3Column } from '@cipherstash/stack/adapter-kit' +import { factoryForDomain } from '@cipherstash/stack/adapter-kit' +import { type AnyV3Table, EncryptedTable } from '@cipherstash/stack/eql/v3' +import type { IntrospectionResult } from './introspect' + +/** A record of declared v3 tables, keyed by table name. */ +export type V3Schemas = Record + +export interface SynthesizedSchema { + /** Every introspected table (even zero-encrypted ones), keyed by table name. + * Values hold ONLY the encrypted columns; plaintext columns live in + * `allColumns`. */ + tables: Map + /** Full column list per table (encrypted + plaintext), for select('*'). */ + allColumns: Map +} + +/** + * Build one `EncryptedTable` per introspected table from its domain columns. + * A column whose `domainName` is NULL or absent from the registry is treated as + * plaintext — retained in `allColumns` but not added to the table. Synthesized + * columns are keyed by DB name (property == DB name). + * + * NOTE: this does NOT reject recognized-but-unmodelled EQL domains — such a + * column silently becomes a plaintext passthrough here, and reads would return + * raw ciphertext. `assertTableIsModelled` (index.ts) is the ONLY thing standing + * between a caller and that leak; it must run before any builder is handed out. + */ +export function synthesizeTables( + introspection: IntrospectionResult, +): SynthesizedSchema { + const tables = new Map() + const allColumns = new Map() + + for (const table of introspection) { + // Null-prototype: keys are DB column names, so `__proto__` must land as an + // own key rather than reparenting the object (which would drop the column). + const builders: Record = Object.create(null) + for (const col of table.columns) { + if (col.domainName === null) continue + const factory = factoryForDomain(col.domainName) + if (!factory) continue // unknown / unmodelled → guarded elsewhere + builders[col.columnName] = factory(col.columnName) + } + // Raw constructor (not `encryptedTable`) — no accessor copy or reserved-key + // guard is needed, and it avoids throwing on an arbitrary DB column name + // that happens to collide with a reserved table member. + tables.set(table.tableName, new EncryptedTable(table.tableName, builders)) + allColumns.set( + table.tableName, + table.columns.map((c) => c.columnName), + ) + } + + return { tables, allColumns } +} + +/** + * Replace synthesized tables with a merge of declared-over-synthesized columns. + * For each declared column, drop the synthesized entry that resolves to the + * same DB name and add the declared builder under its JS property name (so a + * property→DB rename survives). Undeclared columns stay synthesized. + * `allColumns` is unchanged (DB-name based, from introspection). + */ +export function mergeDeclaredTables( + synth: SynthesizedSchema, + schemas: V3Schemas, +): SynthesizedSchema { + const tables = new Map(synth.tables) + + for (const declared of Object.values(schemas)) { + const tableName = declared.tableName + const synthesized = tables.get(tableName) + + const merged: Record = Object.create(null) + if (synthesized) { + for (const [prop, builder] of Object.entries( + synthesized.columnBuilders, + )) { + merged[prop] = builder as AnyEncryptedV3Column + } + } + for (const [prop, builder] of Object.entries(declared.columnBuilders)) { + const dbName = builder.getName() + if (dbName !== prop && Object.hasOwn(merged, dbName)) { + delete merged[dbName] + } + merged[prop] = builder as AnyEncryptedV3Column + } + tables.set(tableName, new EncryptedTable(tableName, merged)) + } + + return { tables, allColumns: synth.allColumns } +} diff --git a/packages/stack-supabase/src/types.ts b/packages/stack-supabase/src/types.ts new file mode 100644 index 000000000..df5fe7865 --- /dev/null +++ b/packages/stack-supabase/src/types.ts @@ -0,0 +1,822 @@ +import type { AuditConfig } from '@cipherstash/stack/adapter-kit' +import type { EncryptionClient } from '@cipherstash/stack/encryption' +import type { + AnyV3Table, + EqlTypeForColumn, + InferPlaintext, + QueryTypesForColumn, +} from '@cipherstash/stack/eql/v3' +import type { EncryptionError } from '@cipherstash/stack/errors' +import type { LockContext } from '@cipherstash/stack/identity' +import type { + EncryptedTable, + EncryptedTableColumn, +} from '@cipherstash/stack/schema' +import type { ClientConfig } from '@cipherstash/stack/types' +import type { V3Schemas } from './schema-builder' + +// --------------------------------------------------------------------------- +// Config & instance +// --------------------------------------------------------------------------- + +export type EncryptedSupabaseConfig = { + encryptionClient: EncryptionClient + supabaseClient: SupabaseClientLike +} + +export interface EncryptedSupabaseInstance { + from = Record>( + tableName: string, + schema: EncryptedTable, + ): EncryptedQueryBuilder +} + +// --------------------------------------------------------------------------- +// EQL v3 config & instance +// --------------------------------------------------------------------------- + +export type { V3Schemas } + +/** + * Options for {@link import('./index').encryptedSupabaseV3}. + * + * @typeParam S - declared v3 tables. When present, `from()` is constrained to + * the declared table names and returns typed builders, and the tables are + * verified against the database at construction. + */ +export type EncryptedSupabaseV3Options< + S extends V3Schemas | undefined = undefined, +> = { + /** Postgres connection string for introspection. Defaults to + * `process.env.DATABASE_URL`. */ + databaseUrl?: string + /** Passed through to the encryption client (`eqlVersion` is forced to 3). */ + config?: ClientConfig + /** + * Optional declared v3 tables, keyed by table name (each record key MUST + * equal its table's `tableName`). Declaring a table adds compile-time types + * and startup verification; undeclared tables behave exactly as with no + * `schemas`. + * + * Declaring a `text_search` column does NOT change its match behaviour: a + * declared and a synthesized `text_search` column build byte-identically, and + * neither `types.TextSearch` nor `EncryptedTextSearchColumn` accepts match + * options. See the `contains` note on `EncryptedQueryBuilderV3Impl`. + */ + schemas?: S +} + +/** + * The column builders declared on a v3 table, recovered from the table's + * type-level `_columnType` brand. + */ +type V3ColumnsOfTable = Table extends { + readonly _columnType: infer C +} + ? C + : never + +/** + * JS property names of a v3 table's storage-only columns — those whose domain + * exposes no query capability (e.g. `types.Bool`, `types.Text`). Excluded from + * the filterable keys so a filter on one is a type error, matching the runtime + * guard in the v3 term encryption path. + */ +export type NonQueryableV3Keys
= { + [K in Extract, string>]: [ + QueryTypesForColumn[K]>, + ] extends [never] + ? K + : never +}[Extract, string>] + +/** + * Row keys a v3 builder accepts in filter methods: every row key except the + * table's storage-only encrypted columns. Plaintext (non-schema) columns pass + * through untouched, exactly as in v2. + */ +export type V3FilterableKeys< + Table extends AnyV3Table, + Row extends Record, +> = Exclude, NonQueryableV3Keys
> + +/** + * JS property names of a v3 table's columns that carry NO `freeTextSearch` + * capability — i.e. every domain but `public.eql_v3_text_match` and + * `public.eql_v3_text_search`. Excluded from `contains()`'s keys, so a token-containment + * query against a column with no bloom-filter index is a type error rather than + * the runtime capability throw in the v3 term encryption path. + */ +type NonFreeTextSearchV3Keys
= { + [K in Extract< + keyof V3ColumnsOfTable
, + string + >]: 'freeTextSearch' extends QueryTypesForColumn[K]> + ? never + : K +}[Extract, string>] + +/** + * Row keys a v3 builder accepts in `contains()`: every row key except the + * table's encrypted columns that lack a match index. Plaintext columns pass + * through, where `contains` is PostgREST's native jsonb/array containment. + */ +export type V3FreeTextSearchableKeys< + Table extends AnyV3Table, + Row extends Record, +> = Exclude, NonFreeTextSearchV3Keys
> + +/** + * Row keys `matches()` accepts: ONLY the table's ENCRYPTED columns that carry a + * `freeTextSearch` capability (`public.eql_v3_text_match` / `text_search`). + * + * Unlike {@link V3FreeTextSearchableKeys} (which additionally lets plaintext keys + * through, because the old `contains` also served native containment), this + * excludes plaintext columns entirely — `matches()` is encrypted free-text only, + * so calling it on a plaintext column is a compile error, not a runtime throw. + * Derived from the encrypted-column keys minus the non-free-text ones. + */ +export type V3EncryptedFreeTextKeys< + Table extends AnyV3Table, + Row extends Record, +> = Exclude< + Extract, string>, + NonFreeTextSearchV3Keys
+> & + Extract + +/** + * The operand `contains()` accepts on a PLAINTEXT column, mirroring + * postgrest-js's own untyped `contains` overload: a jsonb literal, an array, or + * the raw string form. + * + * Deliberately NOT `ReadonlyArray` (postgrest-js's *typed* overload): + * for `tags: string[]` that resolves to `string[][]` and rejects the very call + * it exists to allow, `contains('tags', ['vip'])`. + */ +type NativeContainsValue = string | readonly unknown[] | Record + +/** + * The `contains()` operand for a PLAINTEXT column, derived from the column's own + * declared shape. + * + * `@>` is defined on arrays and on jsonb, never on a scalar: `contains('note', + * ['vip'])` against a plaintext `text` column emits `note.cs.{vip}` and Postgres + * answers 42883 (operator does not exist). A scalar therefore maps to `never`, + * which costs no legitimate call. `string` stays available on the container + * columns for the raw-literal form (`contains('tags', '{vip}')`). + */ +type PlaintextContainsValue = V extends readonly unknown[] + ? V | string + : V extends Record + ? V | string + : never + +/** + * The `contains()` operand for column `K`. + * + * A DECLARED encrypted column reaching `contains` necessarily carries a + * `freeTextSearch` capability — only `public.eql_v3_text_match` and + * `public.eql_v3_text_search` do, and both `cast_as` to `string` — so its operand is + * the string to tokenize into a bloom-filter query term. + * + * Any other key is a plaintext passthrough, where `contains` means PostgREST's + * native jsonb/array containment and the operand follows the column + * ({@link PlaintextContainsValue}). A blanket `value: string` made that half of + * {@link V3FreeTextSearchableKeys} unreachable from TypeScript; a blanket + * {@link NativeContainsValue} then over-corrected, admitting an array on a + * plaintext scalar. + * + * A UNION key is only as permissive as its strictest member: if ANY member is a + * declared column, the operand is the string term. `[K] extends [declared]` gets + * this backwards — a mixed `'email' | 'tags'` fails that test and falls to the + * plaintext branch, so an array typechecks for a key that may resolve to the + * encrypted `email` at runtime. Nothing downstream catches it: the operand goes + * straight to `encrypt()`, which has no plaintext-type guard. + * + * So test the INTERSECTION instead, wrapped in a tuple to stop the naked type + * parameter distributing (which would rebuild the same permissive union). + * + * `PlaintextContainsValue` DOES distribute over `Row[K]`, which is safe only + * because the tuple guard above has already excluded every encrypted member: a + * union of plaintext keys (`'tags' | 'meta'`) must accept the operands of each. + * The residual imprecision is a plaintext scalar unioned with a container column + * (`'note' | 'tags'`), where an array still typechecks — and yields a loud 42883 + * rather than a silent mis-encryption. + */ +export type V3ContainsValue< + Table extends AnyV3Table, + Row extends Record, + K extends string, +> = [Extract, string>>] extends [never] + ? PlaintextContainsValue + : string + +/** + * JS property names of a v3 table's columns that `order()` cannot sort by. Two + * cases: + * + * 1. Columns with NO `orderAndRange` capability — storage-only, equality-only + * and match-only domains hold no ordering term. + * 2. ORE-backed (`*_ord_ore`) columns. They ARE `orderAndRange`-capable, but the + * builder sorts encrypted columns through a jsonb path (`col->op`), and the + * OPE term that path selects does not exist on an ORE domain — its `ob` term + * needs the superuser-only ORE opclass no jsonb path can reach. So they are + * excluded here to match the runtime rejection in `validateTransforms`, + * rather than type-checking clean and throwing at execute time. + */ +export type NonOrderableV3Keys
= { + [K in Extract< + keyof V3ColumnsOfTable
, + string + >]: 'orderAndRange' extends QueryTypesForColumn[K]> + ? EqlTypeForColumn[K]> extends `${string}_ord_ore` + ? K + : never + : K +}[Extract, string>] + +/** + * Row keys a v3 builder accepts in `order()`: every plaintext row key, plus the + * encrypted columns that carry an ordering term. + * + * A bare `ORDER BY col` on an EQL v3 domain IS wrong — the bundle declares no + * btree opclass on any domain, so the sort resolves through jsonb's default + * `jsonb_cmp` and compares the random ciphertext first. But the builder does not + * emit a bare `ORDER BY`: for an encrypted ordering column it emits the jsonb + * path `col->op`, which selects the OPE term, and OPE is order-preserving. See + * `EncryptedQueryBuilderV3Impl.orderColumnName`. + * + * ORE-backed (`*_ord_ore`) columns are excluded at compile time by + * {@link NonOrderableV3Keys} — the builder sorts through a jsonb path that + * cannot reach their superuser-only ORE opclass, so `.order()` on one is a type + * error, matching the runtime rejection in `validateTransforms` (defense in + * depth for the untyped `.order(someString)` path). + */ +export type V3OrderableKeys< + Table extends AnyV3Table, + Row extends Record, +> = Exclude, NonOrderableV3Keys
> + +/** + * Row keys that are NOT encrypted v3 columns. Used where a method's operand is a + * SQL value rather than a ciphertext envelope — `is(col, true)` in particular, + * since an encrypted column holds jsonb and can never be `IS TRUE`. + */ +export type V3PlaintextKeys< + Table extends AnyV3Table, + Row extends Record, +> = Exclude< + Extract, + Extract, string> +> + +/** + * The v3 builder type: the shared {@link EncryptedQueryBuilderCore} surface with + * filter methods narrowed to {@link V3FilterableKeys} and `order()` to + * {@link V3OrderableKeys}. + * + * `like`/`ilike` are absent by construction. EQL v3 free-text search is fuzzy + * bloom-filter token matching (`@>`), not SQL wildcard matching — `%` is + * tokenized like any other character, so a `like` pattern is a category error. + * The v3 dialect of Drizzle omits them for the same reason. Use `matches`. + */ +export interface EncryptedQueryBuilderV3< + Table extends AnyV3Table, + Row extends Record, +> extends EncryptedQueryBuilderCore< + Row, + V3FilterableKeys & StringKeyOf, + EncryptedQueryBuilderV3, + V3OrderableKeys & StringKeyOf, + // `is(col, true)` is legal only on a PLAINTEXT column: an encrypted column + // holds a jsonb envelope, never a SQL boolean. The two axes were threaded + // separately "so they can diverge", and now they have — `order()` admits + // encrypted ordering columns (sorted by their `op` term), `is(col, true)` + // still admits none. + V3PlaintextKeys & StringKeyOf + > { + /** Encrypted free-text token match. Encrypted match/search columns only — + * plaintext columns are a compile error (use {@link contains}). The operand is + * the string to tokenize into a bloom-filter query term. */ + matches & StringKeyOf>( + column: K, + value: string, + ): EncryptedQueryBuilderV3 + /** Native (exact) jsonb/array containment (`@>`). Plaintext columns only — an + * encrypted column is a compile error (use {@link matches}). A scalar plaintext + * column resolves its operand to `never` (`@>` is array/jsonb only). */ + contains & StringKeyOf>( + column: K, + value: PlaintextContainsValue, + ): EncryptedQueryBuilderV3 +} + +/** + * The v3 builder for a table with no declared schema. Without capability + * information `contains` cannot be narrowed to match-indexed columns — the + * runtime guard in the term-encryption path is the only protection — but the + * DIALECT is still v3, so `like`/`ilike` are absent here too. Typing this as + * {@link EncryptedQueryBuilder} would hand back the v2 surface. + * + * For the same reason nothing here can tell an encrypted match column from a + * plaintext jsonb one, so `matches`/`contains` accept the full native operand + * union (which subsumes the encrypted column's `string`); the runtime resolves + * the column and picks the encoding (and rejects the wrong-column-kind pairing). + */ +export interface EncryptedQueryBuilderV3Untyped< + Row extends Record, +> extends EncryptedQueryBuilderCore< + Row, + StringKeyOf, + EncryptedQueryBuilderV3Untyped + > { + /** Fuzzy free-text token match on an encrypted match/search column. The + * operand is always the string term to tokenize (never an array/object), even + * on the untyped surface where the column kind is unknown. */ + matches>( + column: K, + value: string, + ): EncryptedQueryBuilderV3Untyped + /** Native jsonb/array containment on a plaintext column (PostgREST `cs`). */ + contains>( + column: K, + value: NativeContainsValue, + ): EncryptedQueryBuilderV3Untyped +} + +/** Untyped instance (no `schemas`): rows default to `Record` + * and `from` accepts any table name. */ +export interface EncryptedSupabaseV3Instance { + from = Record>( + tableName: string, + ): EncryptedQueryBuilderV3Untyped +} + +/** Typed instance (with `schemas: S`): a declared table name resolves to the + * narrowed v3 builder; any other table name falls back to the untyped surface. + * + * The fallback overload is REQUIRED, not a convenience. The design spec + * promises a gradient — "declare one table, leave the rest introspected; + * undeclared tables behave exactly as they would with no `schemas` at all". + * With only the `keyof S` overload, `schemas: { users }` makes `from('orders')` + * a compile error even though `orders` was introspected and works perfectly at + * runtime. Declaring one table would silently make every other table + * unreachable. + * + * Overload order matters: the literal-constrained signature is declared first, + * so TypeScript prefers it whenever the argument is a declared key and only + * falls through to `string` otherwise. */ +export interface TypedEncryptedSupabaseV3Instance { + from( + table: K, + ): EncryptedQueryBuilderV3> + from = Record>( + table: string, + ): EncryptedQueryBuilderV3Untyped +} + +// --------------------------------------------------------------------------- +// Response +// --------------------------------------------------------------------------- + +export type EncryptedSupabaseResponse = { + data: T | null + error: EncryptedSupabaseError | null + count: number | null + status: number + statusText: string +} + +export type EncryptedSupabaseError = { + message: string + details?: string + hint?: string + code?: string + encryptionError?: EncryptionError +} + +// --------------------------------------------------------------------------- +// Internal builder state +// --------------------------------------------------------------------------- + +export type FilterOp = + | 'eq' + | 'neq' + | 'like' + | 'ilike' + /** Native jsonb/array containment (PostgREST `cs` → `@>`). Plaintext columns + * on the v3 surface; also the encrypted-JSON path where applicable. */ + | 'contains' + /** Encrypted free-text token match (bloom `@>`). v3 encrypted match/search + * columns only. Same `cs` wire operator as `contains`, different semantics. */ + | 'matches' + | 'in' + | 'gt' + | 'gte' + | 'lt' + | 'lte' + | 'is' + +export type PendingFilter = { + op: FilterOp + column: string + value: unknown +} + +export type PendingOrFilter = + | { kind: 'structured'; conditions: PendingOrCondition[] } + | { kind: 'string'; value: string; referencedTable?: string } + +export type PendingOrCondition = { + column: string + op: FilterOp + /** PostgREST's `column.not..` negation. Kept off `op` so the + * `in`-list split and the query-type mapping both key on the real operator. */ + negate?: boolean + value: unknown +} + +export type PendingMatchFilter = { + query: Record +} + +export type PendingNotFilter = { + column: string + op: FilterOp + value: unknown +} + +export type PendingRawFilter = { + column: string + operator: string + value: unknown +} + +export type TransformOp = + | { + kind: 'order' + column: string + options?: { + ascending?: boolean + nullsFirst?: boolean + referencedTable?: string + foreignTable?: string + } + } + | { + kind: 'limit' + count: number + options?: { referencedTable?: string; foreignTable?: string } + } + | { + kind: 'range' + from: number + to: number + options?: { referencedTable?: string; foreignTable?: string } + } + | { kind: 'single' } + | { kind: 'maybeSingle' } + | { kind: 'csv' } + | { kind: 'abortSignal'; signal: AbortSignal } + | { kind: 'throwOnError' } + | { kind: 'returns' } + +export type MutationOp = + | { + kind: 'insert' + data: Record | Record[] + options?: { + count?: 'exact' | 'planned' | 'estimated' + defaultToNull?: boolean + onConflict?: string + } + } + | { + kind: 'update' + data: Record + options?: { count?: 'exact' | 'planned' | 'estimated' } + } + | { + kind: 'upsert' + data: Record | Record[] + options?: { + count?: 'exact' | 'planned' | 'estimated' + onConflict?: string + ignoreDuplicates?: boolean + defaultToNull?: boolean + } + } + | { kind: 'delete'; options?: { count?: 'exact' | 'planned' | 'estimated' } } + +export type ResultMode = 'array' | 'single' | 'maybeSingle' + +// --------------------------------------------------------------------------- +// DB-space brands +// --------------------------------------------------------------------------- + +declare const DbBrand: unique symbol + +/** + * A column name in DB-space — i.e. one PostgREST will recognise. + * + * A v3 table may declare a column whose JS property name differs from its DB + * column name (`createdAt: types.TimestampOrd('created_at')`). Both are + * `string`, so before these brands the compiler could not tell which of the two + * reached PostgREST, and each new column-carrying method silently started out + * broken — that is how `order()` shipped sending `createdAt` to a database that + * only has `created_at`. + * + * Branding the {@link SupabaseQueryBuilder} seam means a property name will not + * type-check where a DB name is required. The only way to obtain a `DbName` is + * to call `filterColumnName()`, so forgetting to translate is now a compile + * error rather than a wrong query. The brand is erased at runtime. + */ +export type DbName = string & { readonly [DbBrand]: 'column' } + +/** A PostgREST select list, DB-space and `::jsonb`-cast. Minted by `addJsonbCasts`/`addJsonbCastsV3`. */ +export type DbSelect = string & { readonly [DbBrand]: 'select' } + +/** A PostgREST `or()` filter string in DB-space. Minted by `rebuildOrString`. */ +export type DbFilterString = string & { readonly [DbBrand]: 'filter' } + +/** A comma-separated `onConflict` column list in DB-space. Minted by `resolveMutationOptions`. */ +export type DbConflictList = string & { readonly [DbBrand]: 'conflict' } + +/** Mutation options, with the one column-carrying member in DB-space. */ +export type DbMutationOptions = Record & { + onConflict?: DbConflictList +} + +// --------------------------------------------------------------------------- +// DB-space IR — the recorded query, with every column name translated. +// +// `toDbSpace()` (see ./query-builder) maps the property-space IR above into +// this one, exactly once, before any column name can reach PostgREST. The +// branded `column` fields make that translation a compile-time obligation: +// `applyFilters`/`buildAndExecuteQuery` consume only these types, so feeding +// them the untranslated `PendingFilter[]` does not type-check. +// --------------------------------------------------------------------------- + +export type DbPendingFilter = Omit & { column: DbName } +export type DbPendingNotFilter = Omit & { + column: DbName +} +export type DbPendingRawFilter = Omit & { + column: DbName +} +export type DbPendingOrCondition = Omit & { + column: DbName +} + +/** Entries rather than a Record: a brand cannot ride on an object key, so this + * is the one translation the compiler cannot enforce. Order is preserved. */ +export type DbPendingMatchFilter = { + entries: Array<{ column: DbName; value: unknown }> +} + +/** Retains the caller's ORIGINAL text for the verbatim fallback (which must be + * forwarded byte-for-byte — `parseOrString`/`rebuildOrString` do not round-trip + * nested `and()` or quoted values) alongside the parsed DB-space conditions + * used by the encrypt-and-rebuild path. Parsing happens once, here. */ +export type DbPendingOrFilter = + | { kind: 'structured'; conditions: DbPendingOrCondition[] } + | { + kind: 'string' + original: string + conditions: DbPendingOrCondition[] + referencedTable?: string + } + +type OrderOp = Extract +export type DbTransformOp = + | Exclude + | (Omit & { column: DbName }) + +type InsertOp = Extract +type UpsertOp = Extract +export type DbMutationOp = + | (Omit & { options?: DbMutationOptions }) + | (Omit & { options?: DbMutationOptions }) + | Extract + | Extract + +/** The whole recorded query, in DB-space. */ +export type DbQuerySpace = { + filters: DbPendingFilter[] + matchFilters: DbPendingMatchFilter[] + notFilters: DbPendingNotFilter[] + rawFilters: DbPendingRawFilter[] + orFilters: DbPendingOrFilter[] + transforms: DbTransformOp[] + mutation: DbMutationOp | null +} + +// --------------------------------------------------------------------------- +// Minimal Supabase client shape (to avoid hard dependency) +// --------------------------------------------------------------------------- + +export interface SupabaseQueryBuilder { + select( + columns?: DbSelect, + options?: { head?: boolean; count?: 'exact' | 'planned' | 'estimated' }, + ): SupabaseQueryBuilder + insert(values: unknown, options?: DbMutationOptions): SupabaseQueryBuilder + update(values: unknown, options?: DbMutationOptions): SupabaseQueryBuilder + upsert(values: unknown, options?: DbMutationOptions): SupabaseQueryBuilder + delete(options?: Record): SupabaseQueryBuilder + eq(column: DbName, value: unknown): SupabaseQueryBuilder + neq(column: DbName, value: unknown): SupabaseQueryBuilder + gt(column: DbName, value: unknown): SupabaseQueryBuilder + gte(column: DbName, value: unknown): SupabaseQueryBuilder + lt(column: DbName, value: unknown): SupabaseQueryBuilder + lte(column: DbName, value: unknown): SupabaseQueryBuilder + like(column: DbName, value: unknown): SupabaseQueryBuilder + ilike(column: DbName, value: unknown): SupabaseQueryBuilder + contains(column: DbName, value: unknown): SupabaseQueryBuilder + is(column: DbName, value: unknown): SupabaseQueryBuilder + in(column: DbName, values: unknown[]): SupabaseQueryBuilder + filter(column: DbName, operator: string, value: unknown): SupabaseQueryBuilder + not(column: DbName, operator: string, value: unknown): SupabaseQueryBuilder + or( + filters: DbFilterString, + options?: { referencedTable?: string; foreignTable?: string }, + ): SupabaseQueryBuilder + match(query: Record): SupabaseQueryBuilder + order(column: DbName, options?: Record): SupabaseQueryBuilder + limit(count: number, options?: Record): SupabaseQueryBuilder + range( + from: number, + to: number, + options?: Record, + ): SupabaseQueryBuilder + single(): SupabaseQueryBuilder + maybeSingle(): SupabaseQueryBuilder + csv(): SupabaseQueryBuilder + abortSignal(signal: AbortSignal): SupabaseQueryBuilder + throwOnError(): SupabaseQueryBuilder + returns(): SupabaseQueryBuilder + then( + onfulfilled?: ((value: unknown) => unknown) | null, + onrejected?: ((reason: unknown) => unknown) | null, + ): Promise +} + +// eslint-disable-next-line @typescript-eslint/no-explicit-any +export interface SupabaseClientLike { + from(table: string): any +} + +// --------------------------------------------------------------------------- +// Re-export for convenience +// --------------------------------------------------------------------------- + +export type { AuditConfig } from '@cipherstash/stack/adapter-kit' +export type { EncryptionClient } from '@cipherstash/stack/encryption' +export type { LockContext } from '@cipherstash/stack/identity' +export type { + EncryptedColumn, + EncryptedTable, + EncryptedTableColumn, +} from '@cipherstash/stack/schema' + +// --------------------------------------------------------------------------- +// Forward declaration for query builder (avoids circular) +// --------------------------------------------------------------------------- + +/** Helper to extract string keys from T */ +type StringKeyOf = Extract + +/** + * Every builder method shared by the v2 and v3 dialects. `Self` is the concrete + * builder each method returns, so a dialect that omits a method (v3 omits + * `like`/`ilike`) does not have it laundered back in by a chained call whose + * return type widened to the base interface. + * + * Free-text search is the ONLY axis on which the two dialects differ: v2 + * matches with SQL wildcards (`like`/`ilike` → `~~`), v3 with token containment + * (`contains` → `@>`). Each adds its own method below. + */ +export interface EncryptedQueryBuilderCore< + T extends Record, + FK extends StringKeyOf, + Self, + /** Keys `order()` accepts. Defaults to `FK`, so the v2 surface is unchanged; + * v3 narrows it to plaintext columns (see {@link V3OrderableKeys}). */ + OK extends StringKeyOf = FK, + /** Keys the BOOLEAN form of `is()` accepts. Defaults to `FK`, so the v2 + * surface is unchanged; v3 narrows it to plaintext columns. Distinct from + * `OK` on purpose: "sortable" and "IS TRUE-able" are different capability + * axes that happen to select the same keys today, and narrowing `order()` + * later must not silently narrow `is()` with it. */ + BK extends StringKeyOf = FK, +> extends PromiseLike> { + /** `columns` defaults to `'*'`, matching supabase-js. A `'*'` select expands + * to the introspected column list when one is available (v3), and otherwise + * throws — v2 has no column list to cast, so `select()` and `select('*')` + * both throw there. */ + select( + columns?: string, + options?: { head?: boolean; count?: 'exact' | 'planned' | 'estimated' }, + ): Self + insert( + data: Partial | Partial[], + options?: { + count?: 'exact' | 'planned' | 'estimated' + defaultToNull?: boolean + onConflict?: string + }, + ): Self + update( + data: Partial, + options?: { count?: 'exact' | 'planned' | 'estimated' }, + ): Self + upsert( + data: Partial | Partial[], + options?: { + count?: 'exact' | 'planned' | 'estimated' + onConflict?: string + ignoreDuplicates?: boolean + defaultToNull?: boolean + }, + ): Self + delete(options?: { count?: 'exact' | 'planned' | 'estimated' }): Self + eq(column: K, value: T[K]): Self + neq(column: K, value: T[K]): Self + gt(column: K, value: T[K]): Self + gte(column: K, value: T[K]): Self + lt(column: K, value: T[K]): Self + lte(column: K, value: T[K]): Self + /** + * `IS NULL` / `IS TRUE` / `IS FALSE`. + * + * The `null` form is widened to EVERY row key, not just the filterable ones. + * `is` is the one predicate never encrypted — `isEncryptableTerm` rejects it + * outright, so no term is collected and no capability guard runs — and a NULL + * plaintext is stored as a SQL NULL rather than a ciphertext. On a v3 + * storage-only column (`types.Boolean`, `types.Integer`, …) `IS NULL` is + * therefore not merely legal but the ONLY predicate available, so narrowing it + * to `FK` would deny the sole query those columns support. + * + * The boolean form narrows to `BK`: `IS TRUE` against a jsonb ciphertext + * column compares an envelope to a plaintext boolean, which is a type error in + * the database, not a filter. `FK` is the wrong gate for it — that set + * excludes only the STORAGE-ONLY columns, so a queryable encrypted column + * (`types.TextSearch`, `types.TextEq`, any `*_ord`) is in `FK` and would still + * compile `is(col, true)`. Every encrypted column stores an envelope, + * capability or not, so `BK` excludes them all. + */ + is(column: K, value: null | boolean): Self + is>(column: K, value: null): Self + in(column: K, values: T[K][]): Self + filter(column: K, operator: string, value: T[K]): Self + not(column: K, operator: string, value: T[K]): Self + or( + filters: string, + options?: { referencedTable?: string; foreignTable?: string }, + ): Self + or( + conditions: PendingOrCondition[], + options?: { referencedTable?: string; foreignTable?: string }, + ): Self + match(query: Partial): Self + // `OK`, not `FK`: v3 cannot order by ANY encrypted column, because PostgREST + // cannot emit `ORDER BY eql_v3.ord_term(col)` and a bare `ORDER BY` sorts the + // ciphertext envelope. `OK` defaults to `FK`, so the v2 surface is unchanged. + order( + column: K, + options?: { + ascending?: boolean + nullsFirst?: boolean + referencedTable?: string + foreignTable?: string + }, + ): Self + limit( + count: number, + options?: { referencedTable?: string; foreignTable?: string }, + ): Self + range( + from: number, + to: number, + options?: { referencedTable?: string; foreignTable?: string }, + ): Self + single(): Self + maybeSingle(): Self + csv(): Self + abortSignal(signal: AbortSignal): Self + throwOnError(): Self + /** Escape hatch: re-types the rows and drops back to the v2 builder surface. */ + returns>(): EncryptedQueryBuilder + withLockContext(lockContext: LockContext): Self + audit(config: AuditConfig): Self +} + +/** The v2 builder: free-text search via SQL wildcard matching. */ +export interface EncryptedQueryBuilder< + T extends Record = Record, + FK extends StringKeyOf = StringKeyOf, +> extends EncryptedQueryBuilderCore> { + like(column: K, pattern: string): EncryptedQueryBuilder + ilike(column: K, pattern: string): EncryptedQueryBuilder +} diff --git a/packages/stack-supabase/src/verify.ts b/packages/stack-supabase/src/verify.ts new file mode 100644 index 000000000..b82371fa7 --- /dev/null +++ b/packages/stack-supabase/src/verify.ts @@ -0,0 +1,64 @@ +import { stripDomainSchema } from '@cipherstash/stack/adapter-kit' +import type { IntrospectionResult } from './introspect' +import type { V3Schemas } from './schema-builder' + +/** + * Verify declared v3 tables against the introspected database. For every + * declared column, assert the column exists and its introspected `domain_name` + * matches the declared (unqualified) `eqlType`. Any mismatch throws at + * construction — a wrong domain is caught here instead of as a 23514 CHECK + * violation on the first query. Declaring a subset of a table's encrypted + * columns is allowed; undeclared columns are synthesized from their domains. + */ +export function verifyDeclaredSchemas( + schemas: V3Schemas, + introspection: IntrospectionResult, +): void { + const index = new Map>() + for (const table of introspection) { + const cols = new Map() + for (const col of table.columns) cols.set(col.columnName, col.domainName) + index.set(table.tableName, cols) + } + + for (const declared of Object.values(schemas)) { + const tableName = declared.tableName + const cols = index.get(tableName) + if (!cols) { + throw new Error( + `[supabase v3]: declared table "${tableName}" was not found in the database`, + ) + } + // Two properties resolving to the same DB column each verify fine, then + // collide in `mergeDeclaredTables` and blow up inside + // `EncryptedTable.build()` — from the eql/v3 layer, naming neither the + // properties nor the `schemas` entry. Catch it here, where both are known. + const dbNameOwner = new Map() + for (const [property, builder] of Object.entries(declared.columnBuilders)) { + const dbName = builder.getName() + const owner = dbNameOwner.get(dbName) + if (owner !== undefined) { + throw new Error( + `[supabase v3]: table "${tableName}" declares properties "${owner}" and "${property}" on the same DB column "${dbName}" — each column may be declared once`, + ) + } + dbNameOwner.set(dbName, property) + } + + for (const builder of Object.values(declared.columnBuilders)) { + const dbName = builder.getName() + if (!cols.has(dbName)) { + throw new Error( + `[supabase v3]: declared column "${tableName}.${dbName}" was not found in the database`, + ) + } + const expected = stripDomainSchema(builder.getEqlType()) + const actual = cols.get(dbName) + if (actual !== expected) { + throw new Error( + `[supabase v3]: column "${tableName}.${dbName}" has domain "${actual ?? '(none)'}" but the schema declares "${expected}"`, + ) + } + } + } +} diff --git a/packages/stack-supabase/tsconfig.json b/packages/stack-supabase/tsconfig.json new file mode 100644 index 000000000..f4f2dacc5 --- /dev/null +++ b/packages/stack-supabase/tsconfig.json @@ -0,0 +1,36 @@ +{ + "compilerOptions": { + "lib": ["ES2022", "DOM"], + "target": "ES2022", + "module": "ESNext", + "moduleDetection": "force", + "allowJs": true, + "esModuleInterop": true, + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "verbatimModuleSyntax": true, + "noEmit": true, + "customConditions": ["node"], + "strict": true, + "skipLibCheck": true, + "noFallthroughCasesInSwitch": true, + "noUnusedLocals": false, + "noUnusedParameters": false, + "paths": { + "@cipherstash/stack": ["../stack/src/index.ts"], + "@cipherstash/stack/adapter-kit": ["../stack/src/adapter-kit.ts"], + "@cipherstash/stack/encryption": ["../stack/src/encryption/index.ts"], + "@cipherstash/stack/schema": ["../stack/src/schema/index.ts"], + "@cipherstash/stack/identity": ["../stack/src/identity/index.ts"], + "@cipherstash/stack/errors": ["../stack/src/errors/index.ts"], + "@cipherstash/stack/types": ["../stack/src/types-public.ts"], + "@cipherstash/stack/eql/v3": ["../stack/src/eql/v3/index.ts"], + "@cipherstash/test-kit": ["../test-kit/src/index.ts"], + "@cipherstash/test-kit/suite": ["../test-kit/src/run-family-suite.ts"], + "@cipherstash/test-kit/catalog": ["../test-kit/src/catalog.ts"], + "@/*": ["../stack/src/*"] + } + }, + "include": ["src/**/*.ts", "__tests__/**/*.ts", "integration/**/*.ts"], + "exclude": ["dist", "node_modules"] +} diff --git a/packages/stack-supabase/tsconfig.typecheck.json b/packages/stack-supabase/tsconfig.typecheck.json new file mode 100644 index 000000000..9d06679f0 --- /dev/null +++ b/packages/stack-supabase/tsconfig.typecheck.json @@ -0,0 +1,4 @@ +{ + "extends": "./tsconfig.json", + "include": ["__tests__/**/*.test-d.ts"] +} diff --git a/packages/stack-supabase/tsup.config.ts b/packages/stack-supabase/tsup.config.ts new file mode 100644 index 000000000..2cdd511e4 --- /dev/null +++ b/packages/stack-supabase/tsup.config.ts @@ -0,0 +1,21 @@ +import { defineConfig } from 'tsup' + +export default defineConfig({ + entry: ['src/index.ts'], + outDir: 'dist', + format: ['cjs', 'esm'], + sourcemap: true, + dts: true, + clean: false, + target: 'es2022', + tsconfig: './tsconfig.json', + // Core + the Postgres/Supabase clients stay external — they are the + // consumer's (peer) dependencies, not bundled into the adapter. + external: [ + '@cipherstash/stack', + '@cipherstash/protect-ffi', + '@supabase/supabase-js', + '@supabase/postgrest-js', + 'pg', + ], +}) diff --git a/packages/stack-supabase/vitest.config.ts b/packages/stack-supabase/vitest.config.ts new file mode 100644 index 000000000..9931d316c --- /dev/null +++ b/packages/stack-supabase/vitest.config.ts @@ -0,0 +1,22 @@ +import { configDefaults, defineConfig } from 'vitest/config' +import { sharedAlias, stackSourceAlias } from '../../vitest.shared' + +export default defineConfig({ + resolve: { + // `sharedAlias` resolves `@cipherstash/stack` + its subpaths (incl. + // adapter-kit) and `@cipherstash/test-kit` to SOURCE; `stackSourceAlias` adds + // stack's internal `@/` alias + the wasm-inline stubs that source needs. + alias: { ...sharedAlias, ...stackSourceAlias }, + }, + test: { + // Integration suites require credentials + a database + PostgREST and THROW + // when unconfigured, so `pnpm test` must never collect them. + exclude: [...configDefaults.exclude, 'integration/**'], + testTimeout: 30000, + hookTimeout: 30000, + typecheck: { + tsconfig: './tsconfig.typecheck.json', + include: ['__tests__/**/*.test-d.ts'], + }, + }, +}) diff --git a/packages/stack/README.md b/packages/stack/README.md index f3e289bb6..7482e7946 100644 --- a/packages/stack/README.md +++ b/packages/stack/README.md @@ -307,11 +307,11 @@ Operator family support for Supabase is being developed in collaboration with th Encrypted data is stored as an [EQL](https://github.com/cipherstash/encrypt-query-language) JSON payload. Install the EQL extension in PostgreSQL to enable searchable queries, then store encrypted data in `eql_v2_encrypted` columns. -The `@cipherstash/stack/drizzle` module provides `encryptedType` for defining encrypted columns and `createEncryptionOperators` for querying them: +The `@cipherstash/stack-drizzle` module provides `encryptedType` for defining encrypted columns and `createEncryptionOperators` for querying them: ```typescript import { pgTable, integer, timestamp } from "drizzle-orm/pg-core" -import { encryptedType, extractEncryptionSchema, createEncryptionOperators } from "@cipherstash/stack/drizzle" +import { encryptedType, extractEncryptionSchema, createEncryptionOperators } from "@cipherstash/stack-drizzle" import { Encryption } from "@cipherstash/stack" // Define schema with encrypted columns @@ -364,6 +364,87 @@ For columns with `searchableJson: true`, three JSONB operators are available: These operators encrypt the JSON path selector using the `steVecSelector` query type and cast it to `eql_v2_encrypted` for use with the EQL PostgreSQL functions. +### EQL v3 Concrete-Type Columns (Drizzle) + +The `@cipherstash/stack-drizzle/v3` module targets EQL v3, where each encrypted column is a **concrete Postgres domain type** (`eql_v3.text_eq`, `eql_v3.integer_ord`, …). Instead of toggling capability flags, you pick a concrete type from the `types` namespace and its query capabilities are fixed by that choice. It is the `/v3` subpath of the same `@cipherstash/stack-drizzle` package whose v2 surface is shown above. + +Declare a Drizzle table using the `types` factories. The suffix encodes the capability: `*Eq` (equality), `*Ord` (order + range, which also covers equality), `*Match` / `TextSearch` (free-text search), and the bare name (e.g. `Text`, `Bigint`) is storage-only. + +```ts +import { pgTable, integer } from "drizzle-orm/pg-core" +import { drizzle } from "drizzle-orm/postgres-js" +import { + types, + createEncryptionOperatorsV3, + extractEncryptionSchemaV3, +} from "@cipherstash/stack-drizzle/v3" +import { EncryptionV3 } from "@cipherstash/stack/v3" + +// Capabilities come from the concrete type — no flags to configure. +const users = pgTable("users", { + id: integer("id").primaryKey().generatedAlwaysAsIdentity(), + email: types.TextEq("email"), // equality: eq / ne / inArray + age: types.IntegerOrd("age"), // order + range: gt/gte/lt/lte, between, asc/desc + bio: types.TextMatch("bio"), // free-text search: contains + balance: types.Bigint("balance"), // storage only (no query capability) +}) +``` + +Derive the v3 schema from the table, build the typed client, and create the capability-checked operators: + +```ts +const usersSchema = extractEncryptionSchemaV3(users) +const client = await EncryptionV3({ schemas: [usersSchema] }) +const ops = createEncryptionOperatorsV3(client) + +const db = drizzle({ client: sqlClient }) +``` + +The operators auto-encrypt their operands and validate them against the column's concrete type. Applying an operator the type doesn't support throws `EncryptionOperatorError`: + +```ts +// Equality — email is TextEq +const exact = await db.select().from(users) + .where(await ops.eq(users.email, "alice@example.com")) + +// Range + ordering — age is IntegerOrd +const adults = await db.select().from(users) + .where(await ops.gte(users.age, 18)) + .orderBy(ops.asc(users.age)) + +const midBand = await db.select().from(users) + .where(await ops.between(users.age, 25, 40)) + +// Set membership — built on equality +const listed = await db.select().from(users) + .where(await ops.inArray(users.email, ["alice@example.com", "bob@example.com"])) + +// Free-text token containment — bio is TextMatch +const coffee = await db.select().from(users) + .where(await ops.contains(users.bio, "coffee")) +``` + +Rows are **pre-encrypted** with `client.bulkEncryptModels(...)` before they reach `db.insert(...).values(...)` — Drizzle never sees plaintext. `Bigint` columns take a native JS `bigint`: + +```ts +const rows = await client.bulkEncryptModels( + [ + { email: "alice@example.com", age: 30, bio: "climbing and coffee", balance: 100_000n }, + { email: "bob@example.com", age: 41, bio: "cycling and coffee", balance: 250_000n }, + ], + usersSchema, +) +if (rows.failure) throw new Error(rows.failure.message) + +await db.insert(users).values(rows.data) +``` + +Notes: + +- **Free-text search uses `ops.contains`** (token containment on a `match` index), not SQL `like` / `ilike`. It matches whole indexed tokens, so `contains(users.bio, "coffee")` finds rows whose `bio` contains the token `coffee`. +- **The concrete type defines the legal operators.** `TextEq` supports `eq` / `ne` / `inArray` / `notInArray`; `*Ord` types add `gt` / `gte` / `lt` / `lte` / `between` / `notBetween` and `asc` / `desc`; `*Match` and `TextSearch` add `contains`; a bare `Text` / `Integer` / `Bigint` column is storage-only. Using an unsupported operator throws `EncryptionOperatorError`. +- Combine conditions with `ops.and` / `ops.or`, and do NULL checks with `ops.isNull` / `ops.isNotNull` (the where-clause operators are `async` and must be `await`ed; `ops.asc` / `ops.desc` are synchronous). + ## Identity-Aware Encryption Lock encryption to a specific user by requiring a valid JWT for decryption. @@ -592,6 +673,16 @@ csValue(valueName) // returns ProtectValue (for nested values) | `@cipherstash/stack/identity` | `LockContext` class and identity types | | `@cipherstash/stack/client` | Client-safe exports (schema builders and types only - no native FFI) | | `@cipherstash/stack/types` | All TypeScript types (`Encrypted`, `Decrypted`, `ClientConfig`, `EncryptionClientConfig`, query types, etc.) | +| `@cipherstash/stack/v3` | `EncryptionV3` typed client plus the EQL v3 authoring DSL (`encryptedTable`, `types`, v3 type helpers) | + +The Drizzle and Supabase integrations are **separate first-party packages** that +depend on `@cipherstash/stack` (they are no longer subpaths of it): + +| Package | Provides | +|-------|-----| +| `@cipherstash/stack-drizzle` | Drizzle ORM integration (EQL v2): `encryptedType`, `extractEncryptionSchema`, `createEncryptionOperators` | +| `@cipherstash/stack-drizzle/v3` | EQL v3 Drizzle integration: `types` column factories, `createEncryptionOperatorsV3`, `extractEncryptionSchemaV3`, `makeEqlV3Column`, `EncryptionOperatorError` | +| `@cipherstash/stack-supabase` | Supabase integration: `encryptedSupabase` (v2) and `encryptedSupabaseV3` (v3) | ## Migration from @cipherstash/protect diff --git a/packages/stack/__tests__/bulk-encrypt-validation.test.ts b/packages/stack/__tests__/bulk-encrypt-validation.test.ts new file mode 100644 index 000000000..a267e0700 --- /dev/null +++ b/packages/stack/__tests__/bulk-encrypt-validation.test.ts @@ -0,0 +1,107 @@ +import { describe, expect, it } from 'vitest' +import { + BulkEncryptOperation, + BulkEncryptOperationWithLockContext, +} from '@/encryption/operations/bulk-encrypt' +import type { + BuildableColumn, + BuildableTable, + BulkEncryptPayload, + Client, +} from '@/types' + +/** + * `EncryptOperation` rejects NaN / ±Infinity / out-of-int64 `bigint` values + * client-side, before they reach protect-ffi (whose behaviour on such a value + * is unobservable — see `helpers/validation.ts`). `BulkEncryptOperation` must + * enforce the same contract: any caller that batches instead of looping — the + * v3 Drizzle `inArray`, for one — otherwise silently loses the guard. + * + * The stub client is never reached: validation must throw first. If a case + * here ever calls into protect-ffi, the fake client surfaces it as a different + * error than the one asserted. + */ +const client = {} as Client + +const column: BuildableColumn = { + getName: () => 'age', + build: () => ({}) as never, +} + +const table: BuildableTable = { + tableName: 'users', + build: () => ({ tableName: 'users', columns: {} }), +} + +const payload = (...values: unknown[]): BulkEncryptPayload => + values.map((plaintext) => ({ plaintext })) as BulkEncryptPayload + +const lockContext = { + ctsToken: { accessToken: 'token' }, +} as never + +describe('BulkEncryptOperation numeric validation', () => { + it.each([ + [Number.NaN, 'Cannot encrypt NaN value'], + [Number.POSITIVE_INFINITY, 'Cannot encrypt Infinity value'], + [Number.NEGATIVE_INFINITY, 'Cannot encrypt Infinity value'], + [2n ** 70n, 'Cannot encrypt bigint value out of int64 range'], + [-(2n ** 70n), 'Cannot encrypt bigint value out of int64 range'], + ])('rejects %s before reaching the FFI', async (value, message) => { + const op = new BulkEncryptOperation(client, payload(value), { + column, + table, + }) + + const result = await op.execute() + + expect(result.failure?.message).toContain(message) + }) + + it('rejects an invalid value anywhere in the list, not just the first', async () => { + const op = new BulkEncryptOperation(client, payload(30, 42, Number.NaN), { + column, + table, + }) + + const result = await op.execute() + + expect(result.failure?.message).toContain('Cannot encrypt NaN value') + }) + + it('still passes null entries through without tripping validation', async () => { + const op = new BulkEncryptOperation(client, [{ plaintext: null }], { + column, + table, + }) + + const result = await op.execute() + + expect(result.failure).toBeUndefined() + expect(result.data).toEqual([{ id: undefined, data: null }]) + }) + + it('accepts in-range bigints at the int64 boundary', async () => { + const op = new BulkEncryptOperation(client, payload(9223372036854775807n), { + column, + table, + }) + + const result = await op.execute() + + // Validation passes, so the stub client is reached — proving the boundary + // value was NOT rejected by the numeric guard. + expect(result.failure?.message).not.toContain('out of int64 range') + }) + + it('enforces the same guard on the lock-context variant', async () => { + const op = new BulkEncryptOperationWithLockContext( + new BulkEncryptOperation(client, payload(Number.NaN), { column, table }), + lockContext, + ) + + const result = await op.execute() + + expect(result.failure?.message).toContain('Cannot encrypt NaN value') + }) +}) diff --git a/packages/stack/__tests__/clerk-provider.test.ts b/packages/stack/__tests__/clerk-provider.test.ts new file mode 100644 index 000000000..df02618a2 --- /dev/null +++ b/packages/stack/__tests__/clerk-provider.test.ts @@ -0,0 +1,33 @@ +import { clerkJwtProvider } from '@cipherstash/test-kit/integration-clerk' +import { afterEach, describe, expect, it } from 'vitest' + +/** + * `clerkJwtProvider`'s "FAIL rather than skip" guard is the load-bearing half of + * the identity suites' no-silent-skip contract: if it were ever weakened to a + * skip or a silent `undefined`, the entire identity suite would go dark while CI + * stayed green. The throw is pure logic — it fires before `createClerkClient`, + * so it needs no live Clerk and belongs here in the credential-free unit suite + * rather than the integration config (which only globs `*.integration.test.ts`). + */ +describe('clerkJwtProvider', () => { + const saved = process.env.CLERK_MACHINE_TOKEN + const savedB = process.env.CLERK_MACHINE_TOKEN_B + afterEach(() => { + if (saved === undefined) delete process.env.CLERK_MACHINE_TOKEN + else process.env.CLERK_MACHINE_TOKEN = saved + if (savedB === undefined) delete process.env.CLERK_MACHINE_TOKEN_B + else process.env.CLERK_MACHINE_TOKEN_B = savedB + }) + + it('throws (does not skip) when the default machine token env var is unset', () => { + delete process.env.CLERK_MACHINE_TOKEN + expect(() => clerkJwtProvider()).toThrow(/missing CLERK_MACHINE_TOKEN/) + }) + + it('names the custom env var it was handed', () => { + delete process.env.CLERK_MACHINE_TOKEN_B + expect(() => clerkJwtProvider('CLERK_MACHINE_TOKEN_B')).toThrow( + /CLERK_MACHINE_TOKEN_B/, + ) + }) +}) diff --git a/packages/stack/__tests__/encrypt-lock-context-guards.test.ts b/packages/stack/__tests__/encrypt-lock-context-guards.test.ts index 6c88f145b..981845eb6 100644 --- a/packages/stack/__tests__/encrypt-lock-context-guards.test.ts +++ b/packages/stack/__tests__/encrypt-lock-context-guards.test.ts @@ -15,9 +15,7 @@ * * Every case runs against both a v2 fluent-builder column and a v3 domain * column: the guards live on the shared `EncryptOperationWithLockContext`, so - * both schema styles must take the identical short-circuit path. Each style - * gets its own client — one client emits exactly one EQL wire format, so - * `Encryption` rejects a mixed v2 + v3 schema set outright. + * both schema styles must take the identical short-circuit path. */ import { beforeEach, describe, expect, it, vi } from 'vitest' @@ -32,6 +30,12 @@ vi.mock('@cipherstash/protect-ffi', () => ({ ProtectError: class ProtectError extends Error {}, newClient: vi.fn(async () => ({ __mock: 'client' })), encrypt: vi.fn(async () => ({ v: 2, c: 'ciphertext' })), + // The model / bulk-model path funnels through `encryptBulk`. Return one + // ciphertext per plaintext so the accept-case reconstruction succeeds. + encryptBulk: vi.fn( + async (_client: unknown, { plaintexts }: { plaintexts: unknown[] }) => + plaintexts.map(() => ({ v: 2, c: 'ciphertext' })), + ), decrypt: vi.fn(async () => 'decrypted'), })) @@ -43,30 +47,34 @@ const users = encryptedTable('users', { const usersV3 = encryptedTableV3('users_v3', { score: types.IntegerOrd('score'), + big: types.BigintOrd('big'), }) // biome-ignore lint/suspicious/noExplicitAny: test helper reads the Result union const failure = (result: any) => result.failure -const clients: Record< - 'v2 fluent builder' | 'v3 domain type', - Awaited> -> = {} as never +let clientV2: Awaited> +let clientV3: Awaited> beforeEach(async () => { vi.clearAllMocks() process.env.CS_WORKSPACE_CRN = 'crn:ap-southeast-2.aws:test-workspace' - clients['v2 fluent builder'] = await Encryption({ schemas: [users] }) - clients['v3 domain type'] = await Encryption({ schemas: [usersV3] }) + // One client per wire format: `Encryption` rejects mixed v2 + v3 schema + // sets (one client emits exactly one wire format), so the two schema + // styles get their own clients and the suites below pick the right one. + clientV2 = await Encryption({ schemas: [users] }) + clientV3 = await Encryption({ schemas: [usersV3] }) }) +const clientFor = (variant: 'v2' | 'v3') => + variant === 'v2' ? clientV2 : clientV3 + describe.each([ - ['v2 fluent builder', { column: users.score, table: users }], - ['v3 domain type', { column: usersV3.score, table: usersV3 }], -] as const)('encrypt with lock context rejects non-finite numbers (%s)', (variant, target) => { - const client = () => clients[variant] + ['v2', { column: users.score, table: users }], + ['v3', { column: usersV3.score, table: usersV3 }], +] as const)('encrypt with lock context rejects non-finite numbers (%s domain)', (variant, target) => { it('rejects NaN and never reaches the FFI', async () => { - const result = await client() + const result = await clientFor(variant) .encrypt(Number.NaN, target) .withLockContext(new LockContext()) @@ -76,7 +84,7 @@ describe.each([ }) it('rejects +Infinity and never reaches the FFI', async () => { - const result = await client() + const result = await clientFor(variant) .encrypt(Number.POSITIVE_INFINITY, target) .withLockContext(new LockContext()) @@ -86,7 +94,7 @@ describe.each([ }) it('rejects -Infinity and never reaches the FFI', async () => { - const result = await client() + const result = await clientFor(variant) .encrypt(Number.NEGATIVE_INFINITY, target) .withLockContext(new LockContext()) @@ -98,7 +106,7 @@ describe.each([ it('accepts a finite number and forwards it to the FFI', async () => { // Positive control: proves the guards above reject *because* of the value, // not because the lock-context path is broken for all numbers. - const result = await client() + const result = await clientFor(variant) .encrypt(42, target) .withLockContext(new LockContext()) @@ -108,3 +116,101 @@ describe.each([ expect(opts.plaintext).toBe(42) }) }) + +// The `bigint` analog of the NaN/±Infinity guard above. `bigint` domains map to +// Postgres `int8`, so a plaintext outside the signed 64-bit range cannot be +// stored and must be rejected. protect-ffi 0.28 ALSO bounds-checks (its +// `encodeBigIntPlaintext` throws a `RangeError`), but the SDK guard rejects +// earlier — before the network call — with a typed `EncryptionError`/Result, +// so it is kept as defense-in-depth. The live matrix suite exercises the same +// rejection over the network (`errorSamples`, secret-gated); these run in CI +// without credentials. Both the direct and lock-context encrypt arms funnel +// through the shared `assertValidNumericValue`, so both are covered. +describe('encrypt rejects out-of-range bigint (i64 bounds)', () => { + const target = { column: usersV3.big, table: usersV3 } + const INT64_MAX = 9223372036854775807n + const INT64_MIN = -9223372036854775808n + + it.each([ + ['i64::MAX', INT64_MAX], + ['i64::MIN', INT64_MIN], + ['zero', 0n], + ['a negative', -42n], + ] as const)('accepts in-range bigint %s and forwards it to the FFI', async (_label, value) => { + const result = await clientV3.encrypt(value, target) + + expect(failure(result)).toBeUndefined() + expect(vi.mocked(ffi.encrypt)).toHaveBeenCalledTimes(1) + expect(vi.mocked(ffi.encrypt).mock.calls[0][1].plaintext).toBe(value) + }) + + it.each([ + ['2^63 (i64::MAX + 1)', 9223372036854775808n], + ['-(2^63) - 1 (i64::MIN - 1)', -9223372036854775809n], + ] as const)('rejects out-of-range bigint %s and never reaches the FFI', async (_label, value) => { + const result = await clientV3.encrypt(value, target) + + expect(failure(result)).toBeDefined() + expect(failure(result)?.message).toContain( + 'Cannot encrypt bigint value out of int64 range', + ) + expect(vi.mocked(ffi.encrypt)).not.toHaveBeenCalled() + }) + + it('rejects out-of-range bigint on the lock-context arm too', async () => { + const result = await clientV3 + .encrypt(9223372036854775808n, target) + .withLockContext(new LockContext()) + + expect(failure(result)).toBeDefined() + expect(failure(result)?.message).toContain( + 'Cannot encrypt bigint value out of int64 range', + ) + expect(vi.mocked(ffi.encrypt)).not.toHaveBeenCalled() + }) +}) + +// The model / bulk-model encrypt path builds the FFI payload directly and does +// NOT flow through the single-value `encrypt` guard, so it validates per field +// in the shared preparers (`prepareFieldsForEncryption` / +// `prepareBulkModelsForOperation`). Prove an out-of-range bigint field is +// rejected there — before `encryptBulk` — on both `encryptModel` and +// `bulkEncryptModels`, and that an in-range bigint still reaches the FFI. +describe('model / bulk encrypt guard out-of-range bigint fields', () => { + const OUT_OF_RANGE = 9223372036854775808n // i64::MAX + 1 + + it('encryptModel rejects an out-of-range bigint field and never reaches the FFI', async () => { + const result = await clientV3.encryptModel({ big: OUT_OF_RANGE }, usersV3) + + expect(failure(result)).toBeDefined() + expect(failure(result)?.message).toContain( + 'Cannot encrypt bigint value out of int64 range', + ) + expect(vi.mocked(ffi.encryptBulk)).not.toHaveBeenCalled() + }) + + it('bulkEncryptModels rejects an out-of-range bigint field and never reaches the FFI', async () => { + const result = await clientV3.bulkEncryptModels( + [{ big: OUT_OF_RANGE }], + usersV3, + ) + + expect(failure(result)).toBeDefined() + expect(failure(result)?.message).toContain( + 'Cannot encrypt bigint value out of int64 range', + ) + expect(vi.mocked(ffi.encryptBulk)).not.toHaveBeenCalled() + }) + + it('encryptModel forwards an in-range bigint field to the FFI', async () => { + // Positive control: proves the rejections above are value-driven, not a + // model path that rejects every bigint. + const result = await clientV3.encryptModel({ big: 42n }, usersV3) + + expect(failure(result)).toBeUndefined() + expect(vi.mocked(ffi.encryptBulk)).toHaveBeenCalledTimes(1) + expect( + vi.mocked(ffi.encryptBulk).mock.calls[0][1].plaintexts[0].plaintext, + ).toBe(42n) + }) +}) diff --git a/packages/stack/__tests__/eql-v3-domain-registry.test.ts b/packages/stack/__tests__/eql-v3-domain-registry.test.ts new file mode 100644 index 000000000..22665d21c --- /dev/null +++ b/packages/stack/__tests__/eql-v3-domain-registry.test.ts @@ -0,0 +1,133 @@ +import fc from 'fast-check' +import { describe, expect, it } from 'vitest' +import { types } from '@/eql/v3' +import { + DOMAIN_REGISTRY, + factoryForDomain, + stripDomainSchema, + type V3ColumnFactory, +} from '@/eql/v3/domain-registry' + +/** + * The EXTERNAL CONTRACT: the SQL domain names this package ships as the + * `information_schema` query parameter (`introspect.ts`) and matches + * `domain_name` rows against. + * + * Hand-written ON PURPOSE. `DOMAIN_REGISTRY` is derived from + * `stripDomainSchema(factory(…).getEqlType())`, so any expectation *also* + * derived from `getEqlType()` only measures the source against itself: corrupt + * a domain constant in `columns.ts` and the registry silently re-keys, the SQL + * param ships the wrong name, real columns are misclassified as unmodelled — + * and a derived assertion still passes. This literal list is the only thing + * that fails. Do not compute it. + */ +const EXPECTED_DOMAIN_KEYS = [ + 'eql_v3_integer', + 'eql_v3_integer_eq', + 'eql_v3_integer_ord_ore', + 'eql_v3_integer_ord', + 'eql_v3_smallint', + 'eql_v3_smallint_eq', + 'eql_v3_smallint_ord_ore', + 'eql_v3_smallint_ord', + 'eql_v3_bigint', + 'eql_v3_bigint_eq', + 'eql_v3_bigint_ord_ore', + 'eql_v3_bigint_ord', + 'eql_v3_date', + 'eql_v3_date_eq', + 'eql_v3_date_ord_ore', + 'eql_v3_date_ord', + 'eql_v3_timestamp', + 'eql_v3_timestamp_eq', + 'eql_v3_timestamp_ord_ore', + 'eql_v3_timestamp_ord', + 'eql_v3_numeric', + 'eql_v3_numeric_eq', + 'eql_v3_numeric_ord_ore', + 'eql_v3_numeric_ord', + 'eql_v3_text', + 'eql_v3_text_eq', + 'eql_v3_text_match', + 'eql_v3_text_ord_ore', + 'eql_v3_text_ord', + 'eql_v3_text_search', + 'eql_v3_boolean', + 'eql_v3_real', + 'eql_v3_real_eq', + 'eql_v3_real_ord_ore', + 'eql_v3_real_ord', + 'eql_v3_double', + 'eql_v3_double_eq', + 'eql_v3_double_ord_ore', + 'eql_v3_double_ord', + 'eql_v3_json', +] as const + +describe('DOMAIN_REGISTRY', () => { + it('strips the public. schema prefix', () => { + expect(stripDomainSchema('public.eql_v3_text_search')).toBe( + 'eql_v3_text_search', + ) + expect(stripDomainSchema('public.eql_v3_integer_ord')).toBe( + 'eql_v3_integer_ord', + ) + // idempotent for an already-unqualified name + expect(stripDomainSchema('boolean')).toBe('boolean') + }) + + it('keys are exactly the expected SQL domain names', () => { + expect(Object.keys(DOMAIN_REGISTRY).sort()).toEqual( + [...EXPECTED_DOMAIN_KEYS].sort(), + ) + }) + + it('maps each expected domain to a factory that builds that domain', () => { + for (const key of EXPECTED_DOMAIN_KEYS) { + const factory = factoryForDomain(key) + expect(factory, `missing registry entry for ${key}`).toBeDefined() + expect((factory as V3ColumnFactory)('c').getEqlType()).toBe( + `public.${key}`, + ) + } + }) + + // The derivation drops an entry rather than throwing only if two factories + // collide on one key; a short registry is that collision. + it('derives one entry per types factory, with no key collisions', () => { + expect(Object.keys(DOMAIN_REGISTRY)).toHaveLength(Object.keys(types).length) + }) + + it('returns undefined for an unknown domain', () => { + expect(factoryForDomain('not_a_domain')).toBeUndefined() + expect(factoryForDomain('eql_v3_text_search')).toBe( + DOMAIN_REGISTRY.eql_v3_text_search, + ) + }) + + it('PROPERTY: rejects any string that is not a registry key', () => { + const keySet = new Set(Object.keys(DOMAIN_REGISTRY)) + fc.assert( + fc.property(fc.string(), (s) => { + fc.pre(!keySet.has(s)) + expect(factoryForDomain(s)).toBeUndefined() + }), + ) + }) +}) + +describe('prototype keys are not domains', () => { + it.each([ + 'constructor', + 'toString', + 'valueOf', + 'hasOwnProperty', + '__proto__', + ])('factoryForDomain(%s) is undefined', (key) => { + expect(factoryForDomain(key)).toBeUndefined() + }) + + it('the registry has a null prototype', () => { + expect(Object.getPrototypeOf(DOMAIN_REGISTRY)).toBeNull() + }) +}) diff --git a/packages/stack/__tests__/error-codes.test.ts b/packages/stack/__tests__/error-codes.test.ts index e4cbc97cd..ad1c7de41 100644 --- a/packages/stack/__tests__/error-codes.test.ts +++ b/packages/stack/__tests__/error-codes.test.ts @@ -5,6 +5,7 @@ import type { EncryptionClient } from '@/encryption' import { EncryptionErrorTypes } from '@/errors' import { Encryption } from '@/index' import { encryptedColumn, encryptedTable } from '@/schema' +import type { BulkDecryptPayload } from '@/types' /** FFI tests require longer timeout due to client initialization */ const FFI_TEST_TIMEOUT = 30_000 @@ -246,29 +247,29 @@ describe('FFI Error Code Preservation', () => { describe('bulkDecrypt error codes', () => { it( - 'returns per-item errors for malformed ciphertexts (fallible FFI decrypt)', + 'returns per-item errors for malformed ciphertexts', async () => { - // bulkDecrypt uses the "fallible" FFI API (decryptBulkFallible): - // - Succeeds at the operation level - // - Returns per-item results with either { data } or { error } - // - // protect-ffi < 0.27 threw a top-level pre-FFI parsing error for - // malformed ciphertexts; 0.27 moved ciphertext parsing INTO the - // fallible API (structured as INVALID_CIPHERTEXT), so the operation - // now succeeds and each bad item carries its own { error } result. + // bulkDecrypt uses the fallible FFI API, so malformed items are + // reported per item instead of failing the whole operation. const invalidCiphertexts = [ { data: { i: { t: 'test_table', c: 'email' }, v: 2, c: 'invalid1' } }, { data: { i: { t: 'test_table', c: 'email' }, v: 2, c: 'invalid2' } }, - ] + ] as unknown as BulkDecryptPayload const result = await protectClient.bulkDecrypt(invalidCiphertexts) - expect(result.failure).toBeUndefined() - if (result.failure) throw new Error('unreachable: asserted above') + if (result.failure) { + throw new Error( + `Expected per-item errors, got ${result.failure.type}`, + ) + } + expect(result.data).toHaveLength(2) + expect(result.data.every((item) => 'error' in item)).toBe(true) + for (const item of result.data) { - expect(item).toHaveProperty('error') - expect((item as { error?: unknown }).error).toBeTruthy() + expect(item.error).toBeDefined() + expect('code' in item).toBe(false) } }, FFI_TEST_TIMEOUT, diff --git a/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql b/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql deleted file mode 100644 index 08da1ff80..000000000 --- a/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql +++ /dev/null @@ -1,36278 +0,0 @@ ---! @file v3/schema.sql ---! @brief EQL v3 schema creation ---! ---! Creates the eql_v3 and eql_v3_internal schemas. eql_v3 is the public API: ---! the self-contained encrypted-domain type families (eql_v3.integer, eql_v3.bigint, ---! and future scalar domains) — their jsonb-backed domains, index-term ---! extractors, aggregates, AND the operator-backing comparison wrappers ---! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment ---! helpers). The wrappers are public because they are the function-form ---! equivalent of every supported operator: platforms without operator support ---! (Supabase/PostgREST calls functions, not operators) invoke them by name. ---! eql_v3_internal houses INTERNAL implementation objects only: the ---! searchable-encrypted-metadata (SEM) index-term types ---! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support ---! functions, the unsupported-operator blockers (which only raise), and the ---! aggregate state functions. Together the two schemas are self-contained — ---! they own every type they need and have no runtime dependency on another EQL ---! schema. ---! ---! Drops existing schema if present to support clean reinstallation. ---! ---! @warning DROP SCHEMA CASCADE will remove all objects in the schema ---! @note eql_v3 is a new, additional schema for the encrypted-domain families. ---! ---! @note DESIGN DECISION — EQL never grants permissions automatically. This ---! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal: ---! access is strictly opt-in. A deployment that exposes EQL to ---! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST) ---! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on ---! the functions it needs. This is intentional least-privilege, not an ---! oversight — see docs/reference/permissions.md. eql_v3_internal is not ---! part of the public API and normally needs no grant; where a caller ---! reaches an internal object indirectly (a public operator/aggregate ---! whose backing state-fn/blocker lives there), grant it deliberately. - ---! @brief Drop existing EQL v3 schema ---! @warning CASCADE will drop all dependent objects -DROP SCHEMA IF EXISTS eql_v3 CASCADE; - ---! @brief Create EQL v3 schema ---! @note Houses the encrypted-domain type families -CREATE SCHEMA eql_v3; - ---! @brief Drop existing EQL v3 internal schema ---! @warning CASCADE will drop all dependent objects -DROP SCHEMA IF EXISTS eql_v3_internal CASCADE; - ---! @brief Create EQL v3 internal implementation schema ---! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their ---! support/constructor/comparator functions, the unsupported-operator ---! blockers (which only raise), the aggregate state functions, and the ---! SteVec CHECK validators. Kept out of the public `eql_v3` surface so ---! internal index-term TYPES do not clutter the Supabase Table Builder ---! type picker. NOTE: the operator-backing comparison *wrappers* are NOT ---! here — they are public in `eql_v3` so every operator has a callable ---! function equivalent for platforms without operator support. -CREATE SCHEMA eql_v3_internal; -COMMENT ON SCHEMA eql_v3_internal IS - 'EQL internal implementation detail; not a public API surface.'; - ---! @brief Schemas owned by the eql_v3 surface ---! ---! Single source of truth for tooling that must enumerate every schema this ---! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a ---! future third eql_v3-family schema is one array literal to edit instead of ---! a hardcoded schema-name predicate repeated at every call site. Keep in ---! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in ---! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into ---! each schema; this drives what tooling scans across both. ---! ---! @return name[] The schema names eql_v3 owns (public + internal). -CREATE FUNCTION eql_v3_internal.owned_schemas() - RETURNS name[] - LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ - SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[] -$$; - ---! @file v3/crypto.sql ---! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) ---! ---! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency ---! closure lives under src/v3/. Enables the pgcrypto extension which provides ---! cryptographic functions used by the eql_v3 ORE comparison path. ---! ---! Installs pgcrypto into the `extensions` schema (Supabase convention) to ---! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto ---! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing ---! install in `public` keeps working — and a pre-existing install anywhere else ---! will be rejected at install time. The body is idempotent ---! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it ---! alongside the eql_v2 copy in a combined install is safe. ---! ---! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes() - ---! @brief Create extensions schema (Supabase convention) -CREATE SCHEMA IF NOT EXISTS extensions; - ---! @brief Enable pgcrypto extension and validate its schema -DO $$ -DECLARE - pgcrypto_schema name; -BEGIN - IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN - CREATE EXTENSION pgcrypto WITH SCHEMA extensions; - END IF; - - SELECT n.nspname INTO pgcrypto_schema - FROM pg_extension e - JOIN pg_namespace n ON n.oid = e.extnamespace - WHERE e.extname = 'pgcrypto'; - - IF pgcrypto_schema = 'extensions' THEN - -- expected location, nothing to say - NULL; - ELSIF pgcrypto_schema = 'public' THEN - RAISE NOTICE - 'pgcrypto is installed in the `public` schema. EQL works against this layout, ' - 'but Supabase splinter will flag it as `extension_in_public`. Move it with: ' - 'ALTER EXTENSION pgcrypto SET SCHEMA extensions'; - ELSE - RAISE EXCEPTION - 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path ' - '(pg_catalog, extensions, public). EQL cryptographic operations would fail at ' - 'runtime. Relocate the extension before installing EQL: ' - 'ALTER EXTENSION pgcrypto SET SCHEMA extensions', - pgcrypto_schema; - END IF; -END $$; - ---! @file v3/common.sql ---! @brief Common utility functions for the self-contained eql_v3 surface. ---! ---! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the ---! one transitive helper it needs without reaching into another schema. The ---! eql_v2 original is unchanged. - ---! @brief Convert JSONB hex array to bytea array ---! @internal ---! ---! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array. ---! Used for deserializing binary data (like ORE terms) from JSONB storage. ---! ---! @param val jsonb JSONB array of hex-encoded strings ---! @return bytea[] Array of decoded binary values ---! ---! @note Returns NULL if input is JSON null ---! @note Each array element is hex-decoded to bytea ---! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the ---! planner can fold this per-encrypted-value helper into the calling query. ---! This deliberately diverges from the v2 plpgsql equivalent (intentionally ---! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only ---! evaluates the set-returning `jsonb_array_elements_text` for an array, so a ---! non-array JSON scalar returns NULL here instead of raising "cannot extract ---! elements from a scalar". Both callers only ever pass an array or JSON null ---! (`val->'ob'`), so the divergence is unreachable in practice; JSON null and ---! empty array still return NULL exactly as before. -CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb) -RETURNS bytea[] - IMMUTABLE -AS $$ - SELECT CASE WHEN jsonb_typeof(val) = 'array' - THEN ( - SELECT array_agg(decode(value::text, 'hex')::bytea) - FROM jsonb_array_elements_text(val) AS value - ) - ELSE NULL - END; -$$ LANGUAGE sql; - ---! @internal Mark this hand-written helper inline-critical so the post-install ---! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving ---! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed ---! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does ---! not recognise it; this marker is the documented manual opt-in. -COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS - 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; - ---! @file v3/sem/ore_block_256/types.sql ---! @brief ORE block index-term types (eql_v3 SEM). ---! ---! Self-contained eql_v3 copies of the Order-Revealing Encryption block types ---! (design D1/D3). The eql_v2 originals are unchanged. - ---! @brief ORE block term type for Order-Revealing Encryption ---! ---! Composite type representing a single ORE block term. Stores encrypted data ---! as bytea that enables range comparisons without decryption. -CREATE TYPE eql_v3_internal.ore_block_256_term AS ( - bytes bytea -); - - ---! @brief ORE block index term type for range queries ---! ---! Composite type containing an array of ORE block terms. The array is stored ---! in the 'ob' field of encrypted data payloads. ---! ---! @note Transient type used only during query execution. -CREATE TYPE eql_v3_internal.ore_block_256 AS ( - terms eql_v3_internal.ore_block_256_term[] -); - ---! @file v3/sem/ore_block_256/functions.sql ---! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). ---! ---! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The ---! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array ---! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and ---! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments ---! deliberately avoid naming eql_v2 symbols so the self-containment grep stays ---! clean.) - ---! @brief Convert JSONB array to ORE block composite type ---! @internal ---! @param val jsonb Array of hex-encoded ORE block terms ---! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null ---! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the ---! planner can fold this per-encrypted-value helper into the calling query. ---! This deliberately diverges from the v2 plpgsql equivalent (intentionally ---! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only ---! evaluates the array path for an array, so a non-array JSON scalar returns ---! NULL here instead of raising. The sole caller (`ore_block_256`) only reaches ---! this when `has_ore_block_256(val)` is true, which now requires `val->'ob'` ---! to be a JSON array, so the non-array branch is unreachable in practice. ---! An empty array (`ob: []`, what encrypting the empty string `""` produces) ---! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms. ---! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and ---! NULL terms make the comparator return NULL (so an empty-text row silently ---! drops out of ordered queries). An empty array instead engages the ---! comparator's `cardinality = 0` guard, which sorts empty BEFORE every ---! non-empty term. See issue #262 (pinned by T7). -CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb) -RETURNS eql_v3_internal.ore_block_256 - IMMUTABLE -AS $$ - SELECT CASE WHEN jsonb_typeof(val) = 'array' - THEN ROW(COALESCE( - ( - SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) - FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b - ), - ARRAY[]::eql_v3_internal.ore_block_256_term[] - ))::eql_v3_internal.ore_block_256 - ELSE NULL - END; -$$ LANGUAGE sql; - ---! @internal Mark this hand-written helper inline-critical so the post-install ---! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving ---! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed ---! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does ---! not recognise it; this marker is the documented manual opt-in. -COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS - 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; - - ---! @brief Extract ORE block index term from JSONB payload ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.ore_block_256 ORE block index term ---! @throws Exception if 'ob' field is missing -CREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb) - RETURNS eql_v3_internal.ore_block_256 - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without - -- entering the body, so no explicit `val IS NULL` guard is needed. - IF eql_v3_internal.has_ore_block_256(val) THEN - RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob'); - END IF; - RAISE 'Expected an ore index (ob) value in json: %', val; - END; -$$ LANGUAGE plpgsql; - - ---! @brief Check if JSONB payload contains an ORE block index term ---! @param val jsonb containing encrypted EQL payload ---! @return boolean True only if the 'ob' field is present and is a JSON array ---! @note A well-formed ORE index term is always a JSON array of block terms, so ---! this guard treats a present-but-non-array `ob` (a scalar or object) as ---! absent. That makes the extractor `ore_block_256(val)` RAISE on a ---! structurally invalid `ob` payload at the boundary instead of silently ---! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The ---! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so ---! reported them as present. `{}` (absent `ob`) and `{"ob": null}` (JSON null) ---! both remain `false`. -CREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false); - END; -$$ LANGUAGE plpgsql; - - ---! @brief Compare two ORE block terms using cryptographic comparison ---! @internal ---! @param a eql_v3_internal.ore_block_256_term First ORE term ---! @param b eql_v3_internal.ore_block_256_term Second ORE term ---! @return integer -1 if a < b, 0 if a = b, 1 if a > b ---! @throws Exception if ciphertexts are different lengths ---! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)` ---! overloads all are). This deliberately diverges from the v2 originals, ---! which carry no volatility marker and so default to `VOLATILE`. The ---! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`, ---! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the ---! planner fold/cache these in ordering and index contexts. NOT `STRICT`: ---! the NULL-handling branches below are load-bearing for the array overload. -CREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term) - RETURNS integer - IMMUTABLE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - eq boolean := true; - unequal_block smallint := 0; - hash_key bytea; - data_block bytea; - encrypt_block bytea; - target_block bytea; - - left_block_size CONSTANT smallint := 16; - right_block_size CONSTANT smallint := 32; - - -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8. - -- Wire format per term: - -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ] - -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49 - -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric - -- (N=14, 702B) with one comparator. - n integer; - left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes) - right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N) - - indicator smallint := 0; - BEGIN - IF a IS NULL AND b IS NULL THEN - RETURN 0; - END IF; - - IF a IS NULL THEN - RETURN -1; - END IF; - - IF b IS NULL THEN - RETURN 1; - END IF; - - IF bit_length(a.bytes) != bit_length(b.bytes) THEN - RAISE EXCEPTION 'Ciphertexts are different lengths'; - END IF; - - -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The - -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0 - -- and derives N = 0, which would fall through to the all-blocks-equal path - -- and return 0 instead of raising. The `<= 16` clause is load-bearing. - IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN - RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes); - END IF; - - n := (octet_length(a.bytes) - 16) / 49; - left_offset := 1 + n; -- left blocks begin right after the N PRP bytes - right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT - - FOR block IN 0..n-1 LOOP - -- Compare each PRP byte (the first N bytes) and its 16-byte left block. - IF - substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1) - OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size) - THEN - IF eq THEN - unequal_block := block; - END IF; - eq = false; - END IF; - END LOOP; - - IF eq THEN - RETURN 0::integer; - END IF; - - -- Hash key is the IV from the right CT of b. - hash_key := substr(b.bytes, right_offset + 1, 16); - - -- First right block is at right_offset + nonce_size (ordinally indexed). - target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size); - - data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size); - - encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb'); - - indicator := ( - get_bit( - encrypt_block, - 0 - ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2; - - IF indicator = 1 THEN - RETURN 1::integer; - ELSE - RETURN -1::integer; - END IF; - END; -$$ LANGUAGE plpgsql; - - ---! @brief Compare arrays of ORE block terms recursively ---! @internal ---! @param a eql_v3_internal.ore_block_256_term[] First array ---! @param b eql_v3_internal.ore_block_256_term[] Second array ---! @return integer -1/0/1, or NULL if either array is NULL -CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[]) -RETURNS integer - IMMUTABLE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - cmp_result integer; - BEGIN - IF a IS NULL OR b IS NULL THEN - RETURN NULL; - END IF; - - IF cardinality(a) = 0 AND cardinality(b) = 0 THEN - RETURN 0; - END IF; - - IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN - RETURN -1; - END IF; - - IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN - RETURN 1; - END IF; - - cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]); - - IF cmp_result = 0 THEN - RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); - END IF; - - RETURN cmp_result; - END -$$ LANGUAGE plpgsql; - - ---! @brief Compare ORE block composite types ---! @internal ---! @param a eql_v3_internal.ore_block_256 First ORE block ---! @param b eql_v3_internal.ore_block_256 Second ORE block ---! @return integer -1/0/1 -CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS integer - IMMUTABLE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms); - END -$$ LANGUAGE plpgsql; - ---! @file v3/sem/ope_cllw/types.sql ---! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM) ---! ---! Domain type representing a CLLW (Copyless Logarithmic Width) ---! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in ---! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the ---! domain carries the hex-decoded bytes. ---! ---! A DOMAIN over bytea, not a composite: the OPE ciphertext is ---! order-preserving under plain byte comparison, so the domain inherits ---! bytea's native comparison operators and DEFAULT btree operator class ---! outright — no hand-written operators, comparator, or operator class (the ---! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole ---! comparison chain inlinable, so a functional btree index on ---! `eql_v3.ord_ope_term(col)` engages structurally for the `_ord_ope` ---! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec ---! CLLW-*ORE* composite compared by a custom per-byte protocol. ---! ---! @note Transient type used only during query execution. ---! @see eql_v3_internal.ope_cllw -CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; - ---! @file v3/sem/hmac_256/types.sql ---! @brief HMAC-SHA256 index term type (eql_v3 SEM) ---! ---! Domain type representing HMAC-SHA256 hash values. Used for exact-match ---! encrypted searches. The hash is stored in the 'hm' field of encrypted data ---! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is ---! unchanged. ---! ---! @note Transient type used only during query execution. -CREATE DOMAIN eql_v3_internal.hmac_256 AS text; - ---! @file v3/sem/bloom_filter/types.sql ---! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. - ---! @brief Bloom-filter index term: a bit array stored as smallint[]. ---! ---! Backs the `match` capability (`@>` / `<@`) on `eql_v3_internal.text_match`. The ---! filter is read from the `bf` field of an encrypted jsonb payload. Native ---! `smallint[]` array-containment (`@>`/`<@`) is inherited through the domain, ---! so this type needs no custom operators. ---! ---! @note Self-contained: references no eql_v2 symbol. -CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; - ---! @file v3/sem/ore_cllw/types.sql ---! @brief CLLW ORE index term type for STE-vec range queries (eql_v3 SEM) ---! ---! Composite type for CLLW (Copyless Logarithmic Width) Order-Revealing ---! Encryption. The ciphertext is stored in the `oc` field of encrypted data ---! payloads (Standard-mode `ste_vec` elements). Used by the range operators ---! (`<`, `<=`, `>`, `>=`) when an sv element carries an `oc` term. ---! ---! The wire-format `oc` value is a hex string with a leading domain-tag byte ---! (`0x00` numeric, `0x01` string) followed by the CLLW ciphertext. The ---! decoded `bytes` field carries the full byte string including the tag — the ---! comparator is variable-length capable, so numeric and string values within ---! the same column order correctly: the domain tag separates the ranges ---! (numeric < string) and the within-domain comparison falls through to the ---! CLLW per-byte protocol. ---! ---! @note This is a transient type used only during query execution. ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE TYPE eql_v3_internal.ore_cllw AS ( - bytes bytea -); --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/timestamp/timestamp_types.sql ---! @brief Encrypted-domain types for timestamp. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.timestamp. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.timestamp_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.timestamp_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.timestamp_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.timestamp_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.timestamp_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; - ---! @file v3/scalars/functions.sql ---! @brief Shared blocker helper for the eql_v3 encrypted-domain families. ---! ---! Per-domain wrapper functions live in src/v3/scalars//. ---! Blockers in those files delegate to encrypted_domain_unsupported_bool ---! so every domain raises a uniform domain-specific error rather than ---! letting an unsupported operator fall through to native jsonb ---! behaviour. - ---! @brief Shared blocker helper. Raises 'operator X is not supported ---! for TYPE' so unsupported domain operators surface a clear ---! error rather than fall through to native jsonb behaviour. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (=, <, @>, ->, etc.) ---! @return boolean (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @brief Shared blocker helper returning jsonb. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! native operators whose result is jsonb (#>, -, #-, ||), so composed ---! expressions resolve and the body raises rather than failing earlier ---! with a misleading 'operator does not exist' on a boolean result. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>, -, #-, ||, etc.) ---! @return jsonb (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @brief Shared blocker helper returning text. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! the native #>> operator whose result is text. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>>) ---! @return text (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) -RETURNS text -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @file v3/sem/ore_block_256/operators.sql ---! @brief Comparison operators on eql_v3_internal.ore_block_256. ---! ---! The six backing functions are inlinable single-statement SQL so the planner ---! can fold the eql_v3 comparison wrappers through to functional-index matching. - ---! @brief Equality backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the ORE blocks are equal ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0 -$$; - ---! @brief Not-equal backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the ORE blocks are not equal ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0 -$$; - ---! @brief Less-than backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the left operand is less than the right operand ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1 -$$; - ---! @brief Less-than-or-equal backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the left operand is less than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1 -$$; - ---! @brief Greater-than backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the left operand is greater than the right operand ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1 -$$; - ---! @brief Greater-than-or-equal backing function for ORE block types ---! @internal ---! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand ---! @return boolean True if the left operand is greater than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1 -$$; - - ---! @brief = operator for ORE block types ---! ---! COMMUTATOR is the operator itself: equality is symmetric. Required for the ---! MERGES flag — without it the planner raises "could not find commutator" the ---! first time an ore_block equality is used as a join qual (e.g. via the inlined ---! eql_v3_internal._ord_ore equality wrappers). -CREATE OPERATOR public.= ( - FUNCTION=eql_v3_internal.ore_block_256_eq, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.=), - NEGATOR = OPERATOR(public.<>), - RESTRICT = eqsel, - JOIN = eqjoinsel, - HASHES, - MERGES -); - ---! @brief <> operator for ORE block types -CREATE OPERATOR public.<> ( - FUNCTION=eql_v3_internal.ore_block_256_neq, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.<>), - NEGATOR = OPERATOR(public.=), - RESTRICT = neqsel, - JOIN = neqjoinsel, - MERGES -); - ---! @brief > operator for ORE block types -CREATE OPERATOR public.> ( - FUNCTION=eql_v3_internal.ore_block_256_gt, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.<), - NEGATOR = OPERATOR(public.<=), - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel -); - ---! @brief < operator for ORE block types -CREATE OPERATOR public.< ( - FUNCTION=eql_v3_internal.ore_block_256_lt, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.>), - NEGATOR = OPERATOR(public.>=), - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel -); - ---! @brief <= operator for ORE block types -CREATE OPERATOR public.<= ( - FUNCTION=eql_v3_internal.ore_block_256_lte, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.>=), - NEGATOR = OPERATOR(public.>), - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel -); - ---! @brief >= operator for ORE block types -CREATE OPERATOR public.>= ( - FUNCTION=eql_v3_internal.ore_block_256_gte, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, - COMMUTATOR = OPERATOR(public.<=), - NEGATOR = OPERATOR(public.<), - RESTRICT = scalargesel, - JOIN = scalargejoinsel -); - ---! @file v3/sem/ope_cllw/functions.sql ---! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM). - ---! @brief Extract CLLW OPE index term from JSONB payload ---! ---! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar ---! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain. ---! ---! Inlinable single-statement SQL — the body is a strict expression of the ---! argument (`->>` and `decode` are both STRICT), so the planner folds this ---! into the calling query and functional btree indexes built on ---! `eql_v3.ord_ope_term(col)` (which calls this) engage structurally, the ---! same way the hmac_256 equality chain does. ---! ---! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and ---! the strict chain propagates it, so the extractor returns SQL NULL and ---! btree's NULL handling filters those rows from range queries. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is ---! absent -CREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb) - RETURNS eql_v3_internal.ope_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw -$$; - -COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)'; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/text/text_types.sql ---! @brief Encrypted-domain types for text. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.text. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_match. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_match' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_match AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'bf' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.text_search. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'text_search' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.text_search AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND VALUE ? 'bf' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; - ---! @file v3/sem/hmac_256/functions.sql ---! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). ---! ---! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and ---! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar ---! domains extract from the jsonb payload directly via a cast to the domain. ---! (Doc comments deliberately avoid naming eql_v2 symbols so the ---! self-containment grep stays clean.) - ---! @brief Extract HMAC-SHA256 index term from JSONB payload ---! ---! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` ---! (which calls this) engage structurally. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent -CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) - RETURNS eql_v3_internal.hmac_256 - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 -$$; - - ---! @brief Check if JSONB payload contains HMAC-SHA256 index term ---! ---! @param val jsonb containing encrypted EQL payload ---! @return boolean True if 'hm' field is present and non-null -CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) - RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm') IS NOT NULL -$$; - ---! @file v3/sem/bloom_filter/functions.sql ---! @brief Extractor for the eql_v3 Bloom-filter SEM index term. ---! ---! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column ---! overloads are intentionally omitted — the eql_v3 scalar domains extract from ---! the jsonb payload directly via a cast to the domain. (Doc comments ---! deliberately avoid naming eql_v2 symbols so the self-containment grep stays ---! clean.) - ---! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term. ---! ---! @param val jsonb The encrypted payload. ---! @return boolean True when the `bf` key is present and non-null. ---! ---! @internal Defined for parity with the eql_v3 SEM index-term predicates ---! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by ---! the extractor below, which gates on value-shape inline, nor by the generated ---! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept ---! as the canonical presence test for callers that need one. -CREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL; - END; -$$ LANGUAGE plpgsql; - ---! @brief Extract the Bloom-filter index term from a jsonb payload. ---! ---! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which ---! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE ---! and no pinned `search_path`. Returns NULL when `bf` is absent or present but ---! not a json array, rather than raising. The `text_match` domain CHECK ---! guarantees the `bf` *key* is present but not that it is an array, so a ---! non-array `bf` (e.g. `{"bf": null}`) can reach here even on a typed value; ---! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for ---! raw jsonb outside the domain — instead of erroring inside ---! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An ---! empty `bf` array yields an empty filter (contains nothing, contained by ---! everything), matching set-containment semantics. ---! ---! @param val jsonb The encrypted payload. ---! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or ---! NULL when `bf` is absent or not a json array. -CREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb) - RETURNS eql_v3_internal.bloom_filter - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array' - THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter - END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/smallint/smallint_types.sql ---! @brief Encrypted-domain types for smallint. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.smallint. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.smallint_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.smallint_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.smallint_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.smallint_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.smallint_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/real/real_types.sql ---! @brief Encrypted-domain types for real. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.real. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.real_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.real_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.real_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.real_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.real_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/numeric/numeric_types.sql ---! @brief Encrypted-domain types for numeric. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.numeric. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.numeric_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.numeric_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.numeric_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.numeric_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.numeric_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/integer/integer_types.sql ---! @brief Encrypted-domain types for integer. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.integer. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.integer_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.integer_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.integer_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.integer_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.integer_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/double/double_types.sql ---! @brief Encrypted-domain types for double. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.double. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.double_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.double_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.double_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.double_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.double_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/date/date_types.sql ---! @brief Encrypted-domain types for date. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.date. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.date_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.date_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.date_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.date_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.date_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/bigint/bigint_types.sql ---! @brief Encrypted-domain types for bigint. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.bigint. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.bigint_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.bigint_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.bigint_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - --! @brief Encrypted domain eql_v3.bigint_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bigint_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; - ---! @file v3/sem/ore_cllw/functions.sql ---! @brief CLLW ORE index-term extraction and comparison (eql_v3 SEM). - ---! @brief Extract CLLW ORE index term from raw jsonb ---! ---! Returns the CLLW ORE ciphertext from the `oc` field of a single sv element ---! supplied as raw jsonb. Inlinable single-statement SQL — the planner folds ---! the body into the calling query. ---! ---! **Missing-`oc` semantics**: returns SQL-level NULL (not a composite with ---! NULL bytes) when `oc` is absent, so btree's NULL handling filters those ---! rows from range queries. ---! ---! @param val jsonb An object carrying an `oc` field ---! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL ---! when the `oc` field is absent. ---! @see eql_v3_internal.has_ore_cllw ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw(val jsonb) - RETURNS eql_v3_internal.ore_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN val ->> 'oc' IS NULL THEN NULL - ELSE ROW(decode(val ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw - END -$$; - -COMMENT ON FUNCTION eql_v3_internal.ore_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW extractor; must stay inlinable (unpinned search_path)'; - ---! @brief Check if a raw jsonb value contains a CLLW ORE index term ---! @param val jsonb An object that may carry an `oc` field ---! @return boolean True if `oc` field is present and non-null -CREATE FUNCTION eql_v3_internal.has_ore_cllw(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT val ->> 'oc' IS NOT NULL -$$; - -COMMENT ON FUNCTION eql_v3_internal.has_ore_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW presence helper; must stay inlinable (unpinned search_path)'; - ---! @brief CLLW per-byte comparison helper ---! @internal ---! ---! Byte-by-byte comparison implementing the CLLW order-revealing protocol. ---! Identify the index of the first differing byte; if `(y_byte + 1) == x_byte` ---! (mod 256) there, then x > y; otherwise x < y. Equal inputs return 0. Inputs ---! MUST be the same length (the caller guarantees this). Stays `LANGUAGE ---! plpgsql` — the per-byte loop can't be a single inlinable SQL expression. ---! ---! @param a bytea First CLLW ciphertext slice ---! @param b bytea Second CLLW ciphertext slice ---! @return integer -1, 0, or 1 ---! @throws Exception if inputs are different lengths ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term_bytes(a bytea, b bytea) -RETURNS int - SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - len_a INT; - len_b INT; - i INT; - first_diff INT := 0; -BEGIN - - len_a := LENGTH(a); - len_b := LENGTH(b); - - IF len_a != len_b THEN - RAISE EXCEPTION 'ore_cllw index terms are not the same length'; - END IF; - - FOR i IN 1..len_a LOOP - IF first_diff = 0 AND get_byte(a, i - 1) != get_byte(b, i - 1) THEN - first_diff := i; - END IF; - END LOOP; - - IF first_diff = 0 THEN - RETURN 0; - END IF; - - IF ((get_byte(b, first_diff - 1) + 1) & 255) = get_byte(a, first_diff - 1) THEN - RETURN 1; - ELSE - RETURN -1; - END IF; -END; -$$ LANGUAGE plpgsql; - ---! @brief Variable-length CLLW ORE term comparison ---! @internal ---! ---! Three-way comparison of two CLLW ORE ciphertext terms of potentially ---! different lengths. Compares the shared prefix via the CLLW per-byte ---! protocol; on equal prefixes, the shorter input sorts first. The leading ---! domain-tag byte makes numeric (`0x00`) sort before string (`0x01`). Stays ---! `LANGUAGE plpgsql` because it dispatches to `compare_ore_cllw_term_bytes`. ---! ---! btree filters NULL composites at the row level, so this should never see a ---! NULL composite under normal operation; the IS-NULL guard returns NULL ---! defensively. A non-NULL composite with NULL `bytes` is a contract violation ---! — the extractor returns SQL NULL (not ROW(NULL)) on missing `oc`, so raise ---! loudly rather than silently misorder. ---! ---! @param a eql_v3_internal.ore_cllw First term ---! @param b eql_v3_internal.ore_cllw Second term ---! @return integer -1, 0, or 1; NULL if either composite is NULL ---! @throws Exception if either composite has a NULL `bytes` field ---! @see eql_v3_internal.compare_ore_cllw_term_bytes -CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) -RETURNS int - SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - len_a INT; - len_b INT; - common_len INT; - cmp_result INT; -BEGIN - -- The `::text` cast is load-bearing, not a stylistic choice. For the - -- single-field `ore_cllw` composite, `ROW(NULL)::ore_cllw IS NULL` is TRUE - -- but `(ROW(NULL)::ore_cllw)::text IS NULL` is FALSE. Casting to text first - -- means a NULL-component composite falls THROUGH to the RAISE below (the - -- extractor-invariant violation) instead of silently returning NULL and - -- masking it. A plain `a IS NULL` would reintroduce that masking bug. - IF a::text IS NULL OR b::text IS NULL THEN - RETURN NULL; - END IF; - - IF a.bytes IS NULL OR b.bytes IS NULL THEN - RAISE EXCEPTION 'eql_v3_internal.compare_ore_cllw_term: composite has NULL bytes field — extractor invariant violated. Check that the index expression uses eql_v3_internal.ore_cllw(...) and not a hand-crafted ROW(NULL).'; - END IF; - - len_a := LENGTH(a.bytes); - len_b := LENGTH(b.bytes); - - IF len_a = 0 AND len_b = 0 THEN - RETURN 0; - ELSIF len_a = 0 THEN - RETURN -1; - ELSIF len_b = 0 THEN - RETURN 1; - END IF; - - IF len_a < len_b THEN - common_len := len_a; - ELSE - common_len := len_b; - END IF; - - cmp_result := eql_v3_internal.compare_ore_cllw_term_bytes( - SUBSTRING(a.bytes FROM 1 FOR common_len), - SUBSTRING(b.bytes FROM 1 FOR common_len) - ); - - IF cmp_result = -1 THEN - RETURN -1; - ELSIF cmp_result = 1 THEN - RETURN 1; - END IF; - - IF len_a < len_b THEN - RETURN -1; - ELSIF len_a > len_b THEN - RETURN 1; - ELSE - RETURN 0; - END IF; -END; -$$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql ---! @brief Functions for eql_v3.timestamp_ord_ore. - ---! @brief Index extractor for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param selector text ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector text) -RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param selector integer ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector integer) -RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ore) -RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b eql_v3.timestamp_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql ---! @brief Functions for eql_v3.timestamp_ord_ope. - ---! @brief Index extractor for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.timestamp_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param selector text ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector text) -RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param selector integer ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector integer) -RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ope) -RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b eql_v3.timestamp_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a eql_v3.timestamp_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_functions.sql ---! @brief Functions for eql_v3.timestamp_ord. - ---! @brief Index extractor for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.timestamp_ord) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param selector text ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector text) -RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param selector integer ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector integer) -RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord) -RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param selector eql_v3.timestamp_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_search_functions.sql ---! @brief Functions for eql_v3.text_search. - ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_search) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_search) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.text_search) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::eql_v3.text_search) $$; - ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) <@ eql_v3.match_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param selector text ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector text) -RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param selector integer ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector integer) -RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a jsonb ---! @param selector eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_search) -RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a jsonb ---! @param selector eql_v3.text_search ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_search) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_search, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_search, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_search, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_search, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_search, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_search, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b eql_v3.text_search) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a jsonb ---! @param b eql_v3.text_search ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_search) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ore_functions.sql ---! @brief Functions for eql_v3.text_ord_ore. - ---! @brief Index extractor for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param selector text ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector text) -RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param selector integer ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector integer) -RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.text_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b eql_v3.text_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a jsonb ---! @param b eql_v3.text_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ope_functions.sql ---! @brief Functions for eql_v3.text_ord_ope. - ---! @brief Index extractor for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord_ope) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.text_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param selector text ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector text) -RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param selector integer ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector integer) -RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ope) -RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.text_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b eql_v3.text_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a eql_v3.text_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord_ope. ---! @param a jsonb ---! @param b eql_v3.text_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_functions.sql ---! @brief Functions for eql_v3.text_ord. - ---! @brief Index extractor for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord) $$; - ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param selector text ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector text) -RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param selector integer ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector integer) -RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param selector eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord) -RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param selector eql_v3.text_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b eql_v3.text_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a jsonb ---! @param b eql_v3.text_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql ---! @brief Functions for eql_v3.smallint_ord_ore. - ---! @brief Index extractor for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.smallint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param selector text ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector text) -RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param selector integer ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector integer) -RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ore) -RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b eql_v3.smallint_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a eql_v3.smallint_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql ---! @brief Functions for eql_v3.smallint_ord_ope. - ---! @brief Index extractor for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.smallint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param selector text ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector text) -RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param selector integer ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector integer) -RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ope) -RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b eql_v3.smallint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a eql_v3.smallint_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.smallint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_functions.sql ---! @brief Functions for eql_v3.smallint_ord. - ---! @brief Index extractor for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.smallint_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; - ---! @brief Operator wrapper for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param selector text ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector text) -RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param selector integer ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector integer) -RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord) -RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param selector eql_v3.smallint_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b eql_v3.smallint_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b eql_v3.smallint_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a eql_v3.smallint_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_ord. ---! @param a jsonb ---! @param b eql_v3.smallint_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ore_functions.sql ---! @brief Functions for eql_v3.real_ord_ore. - ---! @brief Index extractor for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.real_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param selector text ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector text) -RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param selector integer ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector integer) -RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ore) -RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.real_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b eql_v3.real_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a eql_v3.real_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ore. ---! @param a jsonb ---! @param b eql_v3.real_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ope_functions.sql ---! @brief Functions for eql_v3.real_ord_ope. - ---! @brief Index extractor for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.real_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param selector text ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector text) -RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param selector integer ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector integer) -RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ope) -RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.real_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b eql_v3.real_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a eql_v3.real_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord_ope. ---! @param a jsonb ---! @param b eql_v3.real_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_functions.sql ---! @brief Functions for eql_v3.real_ord. - ---! @brief Index extractor for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.real_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.real_ord) $$; - ---! @brief Operator wrapper for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param selector text ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector text) -RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param selector integer ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector integer) -RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param selector eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord) -RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param selector eql_v3.real_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b eql_v3.real_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b eql_v3.real_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a eql_v3.real_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_ord. ---! @param a jsonb ---! @param b eql_v3.real_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql ---! @brief Functions for eql_v3.numeric_ord_ore. - ---! @brief Index extractor for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param selector text ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector text) -RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param selector integer ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector integer) -RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ore) -RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b eql_v3.numeric_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql ---! @brief Functions for eql_v3.numeric_ord_ope. - ---! @brief Index extractor for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.numeric_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param selector text ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector text) -RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param selector integer ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector integer) -RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ope) -RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b eql_v3.numeric_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a eql_v3.numeric_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. ---! @param a jsonb ---! @param b eql_v3.numeric_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_functions.sql ---! @brief Functions for eql_v3.numeric_ord. - ---! @brief Index extractor for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.numeric_ord) $$; - ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector text ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector text) -RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector integer ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector integer) -RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord) -RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b eql_v3.numeric_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ore_functions.sql ---! @brief Functions for eql_v3.integer_ord_ore. - ---! @brief Index extractor for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.integer_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param selector text ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector text) -RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param selector integer ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector integer) -RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ore) -RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.integer_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b eql_v3.integer_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a eql_v3.integer_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ope_functions.sql ---! @brief Functions for eql_v3.integer_ord_ope. - ---! @brief Index extractor for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.integer_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param selector text ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector text) -RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param selector integer ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector integer) -RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ope) -RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.integer_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b eql_v3.integer_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a eql_v3.integer_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. ---! @param a jsonb ---! @param b eql_v3.integer_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_functions.sql ---! @brief Functions for eql_v3.integer_ord. - ---! @brief Index extractor for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.integer_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.integer_ord) $$; - ---! @brief Operator wrapper for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param selector text ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector text) -RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param selector integer ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector integer) -RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param selector eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord) -RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param selector eql_v3.integer_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b eql_v3.integer_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b eql_v3.integer_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a eql_v3.integer_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_ord. ---! @param a jsonb ---! @param b eql_v3.integer_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ore_functions.sql ---! @brief Functions for eql_v3.double_ord_ore. - ---! @brief Index extractor for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.double_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param selector text ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector text) -RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param selector integer ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector integer) -RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ore) -RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.double_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b eql_v3.double_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a eql_v3.double_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ore. ---! @param a jsonb ---! @param b eql_v3.double_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ope_functions.sql ---! @brief Functions for eql_v3.double_ord_ope. - ---! @brief Index extractor for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.double_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param selector text ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector text) -RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param selector integer ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector integer) -RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ope) -RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.double_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b eql_v3.double_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a eql_v3.double_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord_ope. ---! @param a jsonb ---! @param b eql_v3.double_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_functions.sql ---! @brief Functions for eql_v3.double_ord. - ---! @brief Index extractor for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.double_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord) $$; - ---! @brief Operator wrapper for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param selector text ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector text) -RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param selector integer ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector integer) -RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param selector eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord) -RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param selector eql_v3.double_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b eql_v3.double_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b eql_v3.double_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a eql_v3.double_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_ord. ---! @param a jsonb ---! @param b eql_v3.double_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ore_functions.sql ---! @brief Functions for eql_v3.date_ord_ore. - ---! @brief Index extractor for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param selector text ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector text) -RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param selector integer ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector integer) -RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ore) -RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.date_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b eql_v3.date_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ope_functions.sql ---! @brief Functions for eql_v3.date_ord_ope. - ---! @brief Index extractor for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.date_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param selector text ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector text) -RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param selector integer ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector integer) -RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ope) -RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.date_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b eql_v3.date_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a eql_v3.date_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord_ope. ---! @param a jsonb ---! @param b eql_v3.date_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_functions.sql ---! @brief Functions for eql_v3.date_ord. - ---! @brief Index extractor for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.date_ord) $$; - ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param selector text ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector text) -RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param selector integer ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector integer) -RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param selector eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord) -RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param selector eql_v3.date_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b eql_v3.date_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/boolean/boolean_types.sql ---! @brief Encrypted-domain types for boolean. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.boolean. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'boolean' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.boolean AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql ---! @brief Functions for eql_v3.bigint_ord_ore. - ---! @brief Index extractor for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.bigint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param selector text ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector text) -RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param selector integer ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector integer) -RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ore) -RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b eql_v3.bigint_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a eql_v3.bigint_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql ---! @brief Functions for eql_v3.bigint_ord_ope. - ---! @brief Index extractor for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.bigint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) = eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <> eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) < eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) > eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) >= eql_v3.ord_ope_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param selector text ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector text) -RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param selector integer ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector integer) -RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ope) -RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b eql_v3.bigint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a eql_v3.bigint_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. ---! @param a jsonb ---! @param b eql_v3.bigint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_functions.sql ---! @brief Functions for eql_v3.bigint_ord. - ---! @brief Index extractor for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.bigint_ord) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.bigint_ord) $$; - ---! @brief Operator wrapper for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param selector text ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector text) -RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param selector integer ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector integer) -RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord) -RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param selector eql_v3.bigint_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b eql_v3.bigint_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b eql_v3.bigint_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a eql_v3.bigint_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_ord. ---! @param a jsonb ---! @param b eql_v3.bigint_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ -LANGUAGE plpgsql; - ---! @file v3/jsonb/types.sql ---! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! Three jsonb-backed domains (none over another domain — operators resolve ---! against the ultimate base type jsonb, so the native-jsonb firewall in ---! blockers.sql can attach): ---! - eql_v3.json — storage/root: an EQL envelope object ({i, v, ...}). ---! - eql_v3.jsonb_entry — a single sv element (returned by `->`). ---! - eql_v3.jsonb_query — a containment needle (sv elements, no ciphertext). - ---! @brief Validate a single SteVec entry payload. ---! @internal ---! @param val jsonb Candidate entry payload. ---! @return boolean True when `val` is an sv entry with string `s`, string `c`, ---! and exactly one string deterministic term (`hm` XOR `oc`). -CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_entry_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 's') = 'string' - AND jsonb_typeof(val -> 'c') = 'string' - AND ( - (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'oc')) - OR - (jsonb_typeof(val -> 'oc') = 'string' AND NOT (val ? 'hm')) - ), - false - ) -$$; - ---! @brief Validate a SteVec containment query payload. ---! @internal ---! @param val jsonb Candidate query payload. ---! @return boolean True when `val` is `{"sv":[...]}` and every element carries ---! string `s`, no ciphertext, and exactly one string term (`hm` XOR ---! `oc`). -CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_query_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT COALESCE(( - jsonb_typeof(elem) = 'object' - AND jsonb_typeof(elem -> 's') = 'string' - AND NOT (elem ? 'c') - AND ( - (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'oc')) - OR - (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) - ) - ), false) - ), - false - ) -$$; - ---! @brief Validate a root SteVec document payload. ---! @internal ---! @param val jsonb Candidate document payload. ---! @return boolean True when `val` is an encrypted document envelope with ---! `v = 3`, `i`, an `sv` array, and valid sv entry elements. -CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_document_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND val ? 'v' - AND val ->> 'v' = '3' - AND val ? 'i' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT eql_v3_internal.is_valid_ste_vec_entry_payload(elem) - ), - false - ) -$$; - ---! @brief Storage/root domain for an encrypted JSONB column. ---! ---! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index ---! metadata). Root `c` is intentionally NOT required — an sv-array root payload ---! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` ---! array, so the domain accepts only SteVec **document** payloads and rejects ---! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is ---! what keeps `eql_v3.json` a typed document domain rather than a generic ---! encrypted envelope. The firewall in blockers.sql attaches to this domain to ---! stop native jsonb operators from reaching a column value. ---! ---! @note Constructing from inline JSON uses the standard DOMAIN cast: ---! `'{"i":{},"v":3,"sv":[...]}'::eql_v3.json`. -CREATE DOMAIN eql_v3.json AS jsonb - CHECK ( - eql_v3_internal.is_valid_ste_vec_document_payload(VALUE) - ); - ---! @brief Domain type for an individual sv element. ---! ---! A single element inside an `sv` array: a JSON object that carries a selector ---! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for ---! hash-equality) or `oc` (CLLW ORE, for ordered queries) — they are mutually ---! exclusive. This is the type returned by `->` and accepted by the per-entry ---! extractors `eql_v3.eq_term` / `eql_v3.ore_cllw`. Extra fields (`a`, root ---! `i`/`v` merged in by `->`) are allowed. ---! ---! @see src/v3/jsonb/operators.sql -CREATE DOMAIN eql_v3.jsonb_entry AS jsonb - CHECK ( - eql_v3_internal.is_valid_ste_vec_entry_payload(VALUE) - ); - ---! @brief Domain type for an STE-vec containment needle. ---! ---! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index ---! term but **never** a ciphertext (`c`). Each element must carry `s` and ---! exactly one deterministic term (`hm` XOR `oc`). Typing the needle this way ---! stops selector-only needles from casting and matching every row via bare ---! `jsonb @>`. ---! ---! @note Construct from inline JSON via the DOMAIN cast: ---! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.jsonb_query`. ---! @see eql_v3.to_ste_vec_query -CREATE DOMAIN eql_v3.jsonb_query AS jsonb - CHECK ( - eql_v3_internal.is_valid_ste_vec_query_payload(VALUE) - ); - ---! @brief Convert an eql_v3.json to a jsonb_query needle. ---! ---! Normalises each sv element down to the matching-relevant fields: `s` plus ---! exactly one of `hm` / `oc`. Other fields (`c`, `a`, `i`/`v`, anything else) ---! are stripped. This is the canonical needle shape for `@>` containment. ---! Designed for use as a functional GIN index expression: ---! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. ---! ---! @param e eql_v3.json Source encrypted payload ---! @return eql_v3.jsonb_query Query-shaped needle, sv elements normalised. ---! @see eql_v3.jsonb_query -CREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.json) - RETURNS eql_v3.jsonb_query - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT jsonb_build_object( - 'sv', - coalesce( - (SELECT jsonb_agg( - jsonb_strip_nulls( - jsonb_build_object( - 's', elem -> 's', - 'hm', elem -> 'hm', - 'oc', elem -> 'oc' - ) - ) - ) - FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), - '[]'::jsonb - ) - )::eql_v3.jsonb_query -$$; - -CREATE CAST (eql_v3.json AS eql_v3.jsonb_query) - WITH FUNCTION eql_v3.to_ste_vec_query - AS ASSIGNMENT; - ---! @file v3/sem/ore_cllw/operators.sql ---! @brief Comparison operators on the eql_v3_internal.ore_cllw composite type. ---! ---! Each backing function reduces to a single SELECT over ---! eql_v3_internal.compare_ore_cllw_term(a, b) and is inlinable so the planner can fold ---! it through to functional-index matching. The inner comparator is plpgsql ---! (per-byte loop) and is not inlined — fine for index *match*. ---! ---! @note Deliberately no HASHES / MERGES — the CLLW protocol gives ordering, ---! not a hash; there is no merge-joinable opclass on the other side. ---! @see eql_v3_internal.compare_ore_cllw_term - ---! @brief Equality backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the CLLW ORE terms are equal ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_eq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 0 -$$; - ---! @brief Not-equal backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the CLLW ORE terms are not equal ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_neq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 0 -$$; - ---! @brief Less-than backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is less than the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_lt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = -1 -$$; - ---! @brief Less-than-or-equal backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is less than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_lte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 1 -$$; - ---! @brief Greater-than backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is greater than the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_gt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 1 -$$; - ---! @brief Greater-than-or-equal backing function for eql_v3_internal.ore_cllw. ---! @internal ---! ---! @param a eql_v3_internal.ore_cllw Left operand ---! @param b eql_v3_internal.ore_cllw Right operand ---! @return boolean True if the left operand is greater than or equal to the right operand ---! ---! @see eql_v3_internal.compare_ore_cllw_term -CREATE FUNCTION eql_v3_internal.ore_cllw_gte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> -1 -$$; - - -CREATE OPERATOR public.= ( - FUNCTION = eql_v3_internal.ore_cllw_eq, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.=), - NEGATOR = OPERATOR(public.<>), - RESTRICT = eqsel, - JOIN = eqjoinsel -); - -CREATE OPERATOR public.<> ( - FUNCTION = eql_v3_internal.ore_cllw_neq, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.<>), - NEGATOR = OPERATOR(public.=), - RESTRICT = neqsel, - JOIN = neqjoinsel -); - -CREATE OPERATOR public.< ( - FUNCTION = eql_v3_internal.ore_cllw_lt, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.>), - NEGATOR = OPERATOR(public.>=), - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel -); - -CREATE OPERATOR public.<= ( - FUNCTION = eql_v3_internal.ore_cllw_lte, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.>=), - NEGATOR = OPERATOR(public.>), - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel -); - -CREATE OPERATOR public.> ( - FUNCTION = eql_v3_internal.ore_cllw_gt, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.<), - NEGATOR = OPERATOR(public.<=), - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel -); - -CREATE OPERATOR public.>= ( - FUNCTION = eql_v3_internal.ore_cllw_gte, - LEFTARG = eql_v3_internal.ore_cllw, - RIGHTARG = eql_v3_internal.ore_cllw, - COMMUTATOR = OPERATOR(public.<=), - NEGATOR = OPERATOR(public.<), - RESTRICT = scalargesel, - JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql ---! @brief Operators for eql_v3.timestamp_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql ---! @brief Operators for eql_v3.timestamp_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_operators.sql ---! @brief Operators for eql_v3.timestamp_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_functions.sql ---! @brief Functions for eql_v3.timestamp. - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector text ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector text) -RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector integer ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector integer) -RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param selector eql_v3.timestamp ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp) -RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param selector eql_v3.timestamp ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b eql_v3.timestamp) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a jsonb ---! @param b eql_v3.timestamp ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_eq_functions.sql ---! @brief Functions for eql_v3.timestamp_eq. - ---! @brief Index extractor for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.timestamp_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; - ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param selector text ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector text) -RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param selector integer ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector integer) -RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param selector eql_v3.timestamp_eq ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_eq) -RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param selector eql_v3.timestamp_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_search_operators.sql ---! @brief Operators for eql_v3.text_search. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ore_operators.sql ---! @brief Operators for eql_v3.text_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ope_operators.sql ---! @brief Operators for eql_v3.text_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_operators.sql ---! @brief Operators for eql_v3.text_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_functions.sql ---! @brief Functions for eql_v3.text. - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param selector text ---! @return eql_v3.text -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector text) -RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param selector integer ---! @return eql_v3.text -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector integer) -RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param selector eql_v3.text ---! @return eql_v3.text -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text) -RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param selector eql_v3.text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b eql_v3.text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_match_functions.sql ---! @brief Functions for eql_v3.text_match. - ---! @brief Index extractor for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.text_match) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_match) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::eql_v3.text_match) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::eql_v3.text_match) $$; - ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) <@ eql_v3.match_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param selector text ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector text) -RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param selector integer ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector integer) -RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param selector eql_v3.text_match ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_match) -RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param selector eql_v3.text_match ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_match) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_match, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_match, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_match, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_match, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_match, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_match, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_match, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_match, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b eql_v3.text_match) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a jsonb ---! @param b eql_v3.text_match ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_match) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_eq_functions.sql ---! @brief Functions for eql_v3.text_eq. - ---! @brief Index extractor for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_eq) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_eq) $$; - ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param selector text ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector text) -RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param selector integer ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector integer) -RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param selector eql_v3.text_eq ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_eq) -RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param selector eql_v3.text_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b eql_v3.text_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a jsonb ---! @param b eql_v3.text_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql ---! @brief Operators for eql_v3.smallint_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql ---! @brief Operators for eql_v3.smallint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_operators.sql ---! @brief Operators for eql_v3.smallint_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_functions.sql ---! @brief Functions for eql_v3.smallint. - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector text ---! @return eql_v3.smallint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector text) -RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector integer ---! @return eql_v3.smallint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector integer) -RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param selector eql_v3.smallint ---! @return eql_v3.smallint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint) -RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param selector eql_v3.smallint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b eql_v3.smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b eql_v3.smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a eql_v3.smallint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint. ---! @param a jsonb ---! @param b eql_v3.smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_eq_functions.sql ---! @brief Functions for eql_v3.smallint_eq. - ---! @brief Index extractor for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.smallint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.smallint_eq) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.smallint_eq) $$; - ---! @brief Operator wrapper for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param selector text ---! @return eql_v3.smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector text) -RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param selector integer ---! @return eql_v3.smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector integer) -RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param selector eql_v3.smallint_eq ---! @return eql_v3.smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_eq) -RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param selector eql_v3.smallint_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b eql_v3.smallint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b eql_v3.smallint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a eql_v3.smallint_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.smallint_eq. ---! @param a jsonb ---! @param b eql_v3.smallint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ore_operators.sql ---! @brief Operators for eql_v3.real_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ope_operators.sql ---! @brief Operators for eql_v3.real_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_operators.sql ---! @brief Operators for eql_v3.real_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_functions.sql ---! @brief Functions for eql_v3.real. - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector text ---! @return eql_v3.real -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector text) -RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector integer ---! @return eql_v3.real -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector integer) -RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param selector eql_v3.real ---! @return eql_v3.real -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real) -RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param selector eql_v3.real ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b eql_v3.real ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b eql_v3.real) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a eql_v3.real ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real. ---! @param a jsonb ---! @param b eql_v3.real ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_eq_functions.sql ---! @brief Functions for eql_v3.real_eq. - ---! @brief Index extractor for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.real_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.real_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.real_eq) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.real_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.real_eq) $$; - ---! @brief Operator wrapper for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector text ---! @return eql_v3.real_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector text) -RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector integer ---! @return eql_v3.real_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector integer) -RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param selector eql_v3.real_eq ---! @return eql_v3.real_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_eq) -RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param selector eql_v3.real_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b eql_v3.real_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b eql_v3.real_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a eql_v3.real_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.real_eq. ---! @param a jsonb ---! @param b eql_v3.real_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql ---! @brief Operators for eql_v3.numeric_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql ---! @brief Operators for eql_v3.numeric_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_operators.sql ---! @brief Operators for eql_v3.numeric_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_functions.sql ---! @brief Functions for eql_v3.numeric. - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector text ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector text) -RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector integer ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector integer) -RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param selector eql_v3.numeric ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric) -RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param selector eql_v3.numeric ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b eql_v3.numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a jsonb ---! @param b eql_v3.numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_eq_functions.sql ---! @brief Functions for eql_v3.numeric_eq. - ---! @brief Index extractor for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.numeric_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.numeric_eq) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.numeric_eq) $$; - ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector text ---! @return eql_v3.numeric_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector text) -RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector integer ---! @return eql_v3.numeric_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector integer) -RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param selector eql_v3.numeric_eq ---! @return eql_v3.numeric_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_eq) -RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param selector eql_v3.numeric_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b eql_v3.numeric_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ore_operators.sql ---! @brief Operators for eql_v3.integer_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ope_operators.sql ---! @brief Operators for eql_v3.integer_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_operators.sql ---! @brief Operators for eql_v3.integer_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_functions.sql ---! @brief Functions for eql_v3.integer. - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param selector text ---! @return eql_v3.integer -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector text) -RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param selector integer ---! @return eql_v3.integer -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector integer) -RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param selector eql_v3.integer ---! @return eql_v3.integer -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer) -RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param selector eql_v3.integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b eql_v3.integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b eql_v3.integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a eql_v3.integer ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer. ---! @param a jsonb ---! @param b eql_v3.integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_eq_functions.sql ---! @brief Functions for eql_v3.integer_eq. - ---! @brief Index extractor for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.integer_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.integer_eq) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.integer_eq) $$; - ---! @brief Operator wrapper for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector text ---! @return eql_v3.integer_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector text) -RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector integer ---! @return eql_v3.integer_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector integer) -RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param selector eql_v3.integer_eq ---! @return eql_v3.integer_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_eq) -RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param selector eql_v3.integer_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b eql_v3.integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b eql_v3.integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a eql_v3.integer_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.integer_eq. ---! @param a jsonb ---! @param b eql_v3.integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ore_operators.sql ---! @brief Operators for eql_v3.double_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ope_operators.sql ---! @brief Operators for eql_v3.double_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_operators.sql ---! @brief Operators for eql_v3.double_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_functions.sql ---! @brief Functions for eql_v3.double. - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param selector text ---! @return eql_v3.double -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector text) -RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param selector integer ---! @return eql_v3.double -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector integer) -RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param selector eql_v3.double ---! @return eql_v3.double -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double) -RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param selector eql_v3.double ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b eql_v3.double ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b eql_v3.double) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a eql_v3.double ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double. ---! @param a jsonb ---! @param b eql_v3.double ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_eq_functions.sql ---! @brief Functions for eql_v3.double_eq. - ---! @brief Index extractor for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.double_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.double_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.double_eq) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.double_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.double_eq) $$; - ---! @brief Operator wrapper for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector text ---! @return eql_v3.double_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector text) -RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector integer ---! @return eql_v3.double_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector integer) -RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param selector eql_v3.double_eq ---! @return eql_v3.double_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_eq) -RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param selector eql_v3.double_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b eql_v3.double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b eql_v3.double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a eql_v3.double_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.double_eq. ---! @param a jsonb ---! @param b eql_v3.double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ore_operators.sql ---! @brief Operators for eql_v3.date_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ope_operators.sql ---! @brief Operators for eql_v3.date_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_operators.sql ---! @brief Operators for eql_v3.date_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_functions.sql ---! @brief Functions for eql_v3.date. - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param selector text ---! @return eql_v3.date -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector text) -RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param selector integer ---! @return eql_v3.date -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector integer) -RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param selector eql_v3.date ---! @return eql_v3.date -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date) -RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param selector eql_v3.date ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b eql_v3.date) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a jsonb ---! @param b eql_v3.date ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_eq_functions.sql ---! @brief Functions for eql_v3.date_eq. - ---! @brief Index extractor for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.date_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.date_eq) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.date_eq) $$; - ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector text ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector text) -RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector integer ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector integer) -RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param selector eql_v3.date_eq ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_eq) -RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param selector eql_v3.date_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b eql_v3.date_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b eql_v3.date_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/boolean/boolean_functions.sql ---! @brief Functions for eql_v3.boolean. - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector text ---! @return eql_v3.boolean -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector text) -RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector integer ---! @return eql_v3.boolean -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector integer) -RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param selector eql_v3.boolean ---! @return eql_v3.boolean -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.boolean) -RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param selector eql_v3.boolean ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.boolean) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.boolean, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.boolean, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b eql_v3.boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b eql_v3.boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a eql_v3.boolean ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.boolean. ---! @param a jsonb ---! @param b eql_v3.boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql ---! @brief Operators for eql_v3.bigint_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql ---! @brief Operators for eql_v3.bigint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_operators.sql ---! @brief Operators for eql_v3.bigint_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_functions.sql ---! @brief Functions for eql_v3.bigint. - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector text ---! @return eql_v3.bigint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector text) -RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector integer ---! @return eql_v3.bigint -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector integer) -RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param selector eql_v3.bigint ---! @return eql_v3.bigint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint) -RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param selector eql_v3.bigint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b eql_v3.bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b eql_v3.bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a eql_v3.bigint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint. ---! @param a jsonb ---! @param b eql_v3.bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_eq_functions.sql ---! @brief Functions for eql_v3.bigint_eq. - ---! @brief Index extractor for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.bigint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.bigint_eq) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.bigint_eq) $$; - ---! @brief Operator wrapper for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector text ---! @return eql_v3.bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector text) -RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector integer ---! @return eql_v3.bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector integer) -RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param selector eql_v3.bigint_eq ---! @return eql_v3.bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_eq) -RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param selector eql_v3.bigint_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b eql_v3.bigint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b eql_v3.bigint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a eql_v3.bigint_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.bigint_eq. ---! @param a jsonb ---! @param b eql_v3.bigint_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ -LANGUAGE plpgsql; - ---! @file v3/jsonb/functions.sql ---! @brief Extractors, containment engine, and path/array functions for the ---! eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! `selector` parameters here are *encrypted-side* selector hashes — the ---! deterministic hash the crypto layer emits in the `s` field of each sv ---! element. Plaintext JSONPaths are never accepted at runtime. - ------------------------------------------------------------------------------- --- Envelope helpers (eql_v3 owns these; jsonb-only) ------------------------------------------------------------------------------- - ---! @brief Extract metadata (i, v) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return jsonb Metadata object with `i` and `v` fields. -CREATE FUNCTION eql_v3.meta_data(val jsonb) - RETURNS jsonb - IMMUTABLE STRICT PARALLEL SAFE - LANGUAGE SQL -AS $$ - SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); -$$; - -COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS - 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; - ---! @brief Extract ciphertext (c) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text Base64-encoded ciphertext. ---! @throws Exception if `c` is absent. -CREATE FUNCTION eql_v3.ciphertext(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'c' THEN - RETURN val->>'c'; - END IF; - RAISE 'Expected a ciphertext (c) value in json: %', val; - END; -$$ LANGUAGE plpgsql; - ------------------------------------------------------------------------------- --- Selector extractors ------------------------------------------------------------------------------- - ---! @brief Extract selector (s) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text The selector value. ---! @throws Exception if `s` is absent. -CREATE FUNCTION eql_v3.selector(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 's' THEN - RETURN val->>'s'; - END IF; - RAISE 'Expected a selector index (s) value in json: %', val; - END; -$$ LANGUAGE plpgsql; - ---! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK ---! guarantees `s` is present, so this is a simple field access. ---! @param entry eql_v3.jsonb_entry ---! @return text The selector value. -CREATE FUNCTION eql_v3.selector(entry eql_v3.jsonb_entry) - RETURNS text - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT entry ->> 's' -$$; - ------------------------------------------------------------------------------- --- Equality-term extractor (XOR-aware: coalesce(hm, oc)) ------------------------------------------------------------------------------- - ---! @brief XOR-aware equality term extractor for eql_v3.jsonb_entry. ---! ---! Returns the bytea of whichever deterministic term the sv entry carries — ---! `hm` (HMAC-256) or `oc` (CLLW ORE). The two byte distributions are disjoint ---! by construction, so byte equality on the coalesce is unambiguous. Canonical ---! equality extractor used by `=` / `<>` on jsonb_entry. ---! ---! @param entry eql_v3.jsonb_entry ---! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). -CREATE FUNCTION eql_v3.eq_term(entry eql_v3.jsonb_entry) - RETURNS bytea - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT decode(coalesce(entry ->> 'hm', entry ->> 'oc'), 'hex') -$$; - ------------------------------------------------------------------------------- --- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) ------------------------------------------------------------------------------- - ---! @brief Extract CLLW ORE index term from a ste_vec entry. ---! ---! `oc` is only ever present on an sv element, never at a root encrypted value, ---! so the typed overload accepts eql_v3.jsonb_entry. Returns SQL NULL when ---! `oc` is absent (btree NULL-filters such rows from range queries). ---! ---! @param entry eql_v3.jsonb_entry ---! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL. ---! @see eql_v3.has_ore_cllw -CREATE FUNCTION eql_v3.ore_cllw(entry eql_v3.jsonb_entry) - RETURNS eql_v3_internal.ore_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN entry ->> 'oc' IS NULL THEN NULL - ELSE ROW(decode(entry ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw - END -$$; - ---! @brief Check if a ste_vec entry contains a CLLW ORE index term. ---! @param entry eql_v3.jsonb_entry ---! @return boolean True if `oc` is present and non-null. -CREATE FUNCTION eql_v3.has_ore_cllw(entry eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT entry ->> 'oc' IS NOT NULL -$$; - ------------------------------------------------------------------------------- --- sv-array helpers ------------------------------------------------------------------------------- - ---! @brief Extract the sv element array as raw jsonb[]. ---! ---! Returns the elements of `sv` (or a single-element array wrapping the value ---! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. ---! ---! @param val jsonb encrypted EQL payload ---! @return jsonb[] Array of sv elements. -CREATE FUNCTION eql_v3.ste_vec(val jsonb) - RETURNS jsonb[] - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb; - ary jsonb[]; - BEGIN - IF val ? 'sv' THEN - sv := val->'sv'; - ELSE - sv := jsonb_build_array(val); - END IF; - - SELECT array_agg(elem) - INTO ary - FROM jsonb_array_elements(sv) AS elem; - - RETURN ary; - END; -$$ LANGUAGE plpgsql; - ---! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). ---! @param val jsonb encrypted EQL payload ---! @return boolean True if `a` is present and true. -CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'a' THEN - RETURN (val->>'a')::boolean; - END IF; - RETURN false; - END; -$$ LANGUAGE plpgsql; - ------------------------------------------------------------------------------- --- Deterministic-fields array for GIN containment ------------------------------------------------------------------------------- - ---! @brief Extract deterministic search fields (s, hm, oc, op) per sv element. ---! ---! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can ---! compare for containment. Use for GIN indexes and containment queries. ---! ---! @param val jsonb encrypted EQL payload ---! @return jsonb[] Array of objects with only deterministic fields. -CREATE FUNCTION eql_v3.jsonb_array(val jsonb) -RETURNS jsonb[] -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT ARRAY( - SELECT jsonb_object_agg(kv.key, kv.value) - FROM jsonb_array_elements( - CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END - ) AS elem, - LATERAL jsonb_each(elem) AS kv(key, value) - WHERE kv.key IN ('s', 'hm', 'oc', 'op') - GROUP BY elem - ); -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS - 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; - ------------------------------------------------------------------------------- --- Containment ------------------------------------------------------------------------------- - ---! @brief GIN-indexable containment check: does `a` contain all of `b`? ---! @param a jsonb Container payload. ---! @param b jsonb Search payload. ---! @return boolean True if a contains all deterministic elements of b. ---! @note Public raw-`jsonb[]` containment helper over the extracted ---! deterministic fields — the function-form entrypoint for containment on ---! platforms without operator support (Supabase/PostgREST). The typed ---! `eql_v3.json` `@>` operator does NOT call this function — it binds to ---! `eql_v3.ste_vec_contains` instead — but both agree on the result (a ---! parity test pins this). Also the documented GIN index expression ---! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. -CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; - ---! @brief GIN-indexable "is contained by" check. ---! @param a jsonb Payload to check. ---! @param b jsonb Container payload. ---! @return boolean True if all elements of a are contained in b. ---! @note Public raw-`jsonb[]` reverse-containment helper — the function-form ---! entrypoint for `<@` on platforms without operator support. The typed ---! `eql_v3.json` `<@` operator binds to `eql_v3.ste_vec_contains` instead, ---! but both agree on the result. -CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; - ---! @brief Check if an sv array contains a specific sv element. ---! ---! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, ---! oc)). This collapses the v2 hm/oc CASE: under the XOR contract both terms ---! are deterministic and byte-disjoint, so either one is a valid equality ---! discriminator and a single byte comparison is correct. ---! ---! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and oc byte ---! distributions never collide at a given selector. The crypto layer configures ---! a selector for eq XOR ordered, so both sides of a real comparison carry the ---! same term type; and an oc value carries a leading domain-tag byte an hm never ---! has. Unlike v2's explicit `has_hmac(both)`/`has_ore_cllw(both)`/`ELSE false` ---! CASE, this collapse would wrongly match an hm needle against an oc leaf if ---! their hex bytes were ever identical — which the contract prevents. The ---! negative-containment test guards against regression. ---! ---! @param a jsonb[] sv array to search within. ---! @param b jsonb sv element to search for. ---! @return boolean True if b is found in any element of a. -CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - result boolean; - _a jsonb; - BEGIN - result := false; - - FOR idx IN 1..array_length(a, 1) LOOP - _a := a[idx]; - result := result OR ( - eql_v3.selector(_a) = eql_v3.selector(b) - AND eql_v3.eq_term(_a::eql_v3.jsonb_entry) = eql_v3.eq_term(b::eql_v3.jsonb_entry) - ); - EXIT WHEN result; - END LOOP; - - RETURN result; - END; -$$ LANGUAGE plpgsql; - ---! @brief Does encrypted value `a` contain all sv elements of `b`? ---! ---! Empty b is always contained. Each element of b must match selector + eq_term ---! in some element of a. ---! ---! @param a eql_v3.json Container. ---! @param b eql_v3.json Elements to find. ---! @return boolean True if all elements of b are contained in a. ---! @see eql_v3.ste_vec_contains(jsonb[], jsonb) -CREATE FUNCTION eql_v3.ste_vec_contains(a eql_v3.json, b eql_v3.json) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - result boolean; - sv_a jsonb[]; - sv_b jsonb[]; - _b jsonb; - BEGIN - sv_a := eql_v3.ste_vec(a); - sv_b := eql_v3.ste_vec(b); - - IF array_length(sv_b, 1) IS NULL THEN - RETURN true; - END IF; - - IF array_length(sv_a, 1) IS NULL THEN - RETURN false; - END IF; - - result := true; - - FOR idx IN 1..array_length(sv_b, 1) LOOP - _b := sv_b[idx]; - result := result AND eql_v3.ste_vec_contains(sv_a, _b); - END LOOP; - - RETURN result; - END; -$$ LANGUAGE plpgsql; - ------------------------------------------------------------------------------- --- Path queries (text selector only) ------------------------------------------------------------------------------- - ---! @brief Query encrypted JSONB for sv elements matching `selector`. ---! ---! Returns one jsonb_entry row per matching encrypted element. Returns empty ---! set on no match. It deliberately does not wrap multiple matches as an ---! eql_v3.json document, because the root document domain requires an `sv` ---! array and single leaves belong to eql_v3.jsonb_entry. ---! ---! @param val jsonb encrypted EQL payload with `sv`. ---! @param selector text Selector hash (`s` value). ---! @return SETOF eql_v3.jsonb_entry Matching encrypted entries. ---! @see eql_v3.jsonb_path_query_first -CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) - RETURNS SETOF eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; - ---! @brief Check if a selector path exists in encrypted JSONB. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to test. ---! @return boolean True if a matching element exists. -CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT EXISTS ( - SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - ); -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; - ---! @brief Get the first sv element matching `selector`, or NULL. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to match. ---! @return eql_v3.jsonb_entry First matching element or NULL. -CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) - RETURNS eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - LIMIT 1 -$$; - -COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; - ------------------------------------------------------------------------------- --- Array functions ------------------------------------------------------------------------------- - ---! @brief Get the length of an encrypted JSONB array. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return integer Number of elements. ---! @throws Exception 'cannot get array length of a non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) - RETURNS integer - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF eql_v3_internal.is_ste_vec_array(val) THEN - sv := eql_v3.ste_vec(val); - RETURN array_length(sv, 1); - END IF; - - RAISE 'cannot get array length of a non-array'; - END; -$$ LANGUAGE plpgsql; - ---! @brief Extract elements of an encrypted JSONB array as rows. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF eql_v3.jsonb_entry One row per element (metadata preserved). ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) - RETURNS SETOF eql_v3.jsonb_entry - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - meta jsonb; - item jsonb; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; - - meta := eql_v3.meta_data(val); - sv := eql_v3.ste_vec(val); - - FOR idx IN 1..array_length(sv, 1) LOOP - item = sv[idx]; - RETURN NEXT (meta || item)::eql_v3.jsonb_entry; - END LOOP; - - RETURN; - END; -$$ LANGUAGE plpgsql; - ---! @brief Extract elements of an encrypted JSONB array as ciphertext text. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF text One ciphertext per element. ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) - RETURNS SETOF text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; - - sv := eql_v3.ste_vec(val); - - FOR idx IN 1..array_length(sv, 1) LOOP - RETURN NEXT eql_v3.ciphertext(sv[idx]); - END LOOP; - - RETURN; - END; -$$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE --- Source is src/v3/version.template - -DROP FUNCTION IF EXISTS eql_v3.version(); - ---! @file v3/version.sql ---! @brief EQL version reporting (self-contained eql_v3 surface) ---! ---! This file is auto-generated from src/v3/version.template during build. ---! The 3.0.0-alpha.2 placeholder is replaced with the actual release ---! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, ---! or "DEV" for development builds. - ---! @brief Get the installed EQL version string ---! ---! Returns the version string for the installed EQL library. This value is ---! baked in at build time from the release tag. ---! ---! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) ---! ---! @note Auto-generated during build from src/v3/version.template ---! ---! @example ---! -- Check installed EQL version ---! SELECT eql_v3.version(); ---! -- Returns: '3.0.0' -CREATE FUNCTION eql_v3.version() - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT '3.0.0-alpha.2'; -$$ LANGUAGE SQL; - ---! @brief Schema-level version marker for obj_description() discoverability ---! ---! Mirrors eql_v3.version() as a comment on the schema so the installed ---! version can also be read via obj_description('eql_v3'::regnamespace). -COMMENT ON SCHEMA eql_v3 IS '3.0.0-alpha.2'; - ---! @file v3/sem/ore_cllw/operator_class.sql ---! @brief Btree operator class on the eql_v3_internal.ore_cllw composite type. ---! ---! DEFAULT FOR TYPE so a functional btree index on eql_v3_internal.ore_cllw(expr) ---! engages without an explicit opclass annotation. FUNCTION 1 is the three-way ---! comparator btree's internal sort uses; it is plpgsql by design (per-byte ---! CLLW protocol needs iteration) and is called once per index-entry pair ---! during build / search, not per-row in the outer query. ---! ---! @note Excluded from the Supabase build variant by the build glob ---! `**/*operator_class.sql`. ---! @see eql_v3_internal.compare_ore_cllw_term - -CREATE OPERATOR FAMILY eql_v3_internal.ore_cllw_ops USING btree; - -CREATE OPERATOR CLASS eql_v3_internal.ore_cllw_ops - DEFAULT FOR TYPE eql_v3_internal.ore_cllw - USING btree FAMILY eql_v3_internal.ore_cllw_ops AS - OPERATOR 1 public.< (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - OPERATOR 2 public.<= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - OPERATOR 3 public.= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - OPERATOR 4 public.>= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - OPERATOR 5 public.> (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), - FUNCTION 1 eql_v3_internal.compare_ore_cllw_term(eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw); - ---! @file v3/sem/ore_block_256/operator_class.sql ---! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256. ---! ---! Gives the composite type its DEFAULT btree opclass so the recommended ---! functional index `CREATE INDEX ON t (eql_v3_internal.ord_term(col))` engages without ---! an explicit opclass annotation (design D4). Excluded from the Supabase build ---! variant by the `**/*operator_class.sql` glob. - ---! @brief B-tree operator family for ORE block types -CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree; - ---! @brief B-tree operator class for ORE block encrypted values ---! ---! Supports operators: <, <=, =, >=, >. Uses comparison function ---! compare_ore_block_256_terms. -CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class DEFAULT FOR TYPE eql_v3_internal.ore_block_256 USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS - OPERATOR 1 public.<, - OPERATOR 2 public.<=, - OPERATOR 3 public.=, - OPERATOR 4 public.>=, - OPERATOR 5 public.>, - FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.timestamp_ord_ore. - ---! @brief State function for min on eql_v3.timestamp_ord_ore. ---! @param state eql_v3.timestamp_ord_ore ---! @param value eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) -RETURNS eql_v3.timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.timestamp_ord_ore. ---! @param input eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.timestamp_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.timestamp_ord_ore. ---! @param state eql_v3.timestamp_ord_ore ---! @param value eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) -RETURNS eql_v3.timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.timestamp_ord_ore. ---! @param input eql_v3.timestamp_ord_ore ---! @return eql_v3.timestamp_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.timestamp_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.timestamp_ord_ope. - ---! @brief State function for min on eql_v3.timestamp_ord_ope. ---! @param state eql_v3.timestamp_ord_ope ---! @param value eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) -RETURNS eql_v3.timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.timestamp_ord_ope. ---! @param input eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.timestamp_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.timestamp_ord_ope. ---! @param state eql_v3.timestamp_ord_ope ---! @param value eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) -RETURNS eql_v3.timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.timestamp_ord_ope. ---! @param input eql_v3.timestamp_ord_ope ---! @return eql_v3.timestamp_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.timestamp_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql ---! @brief Aggregates for eql_v3.timestamp_ord. - ---! @brief State function for min on eql_v3.timestamp_ord. ---! @param state eql_v3.timestamp_ord ---! @param value eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) -RETURNS eql_v3.timestamp_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.timestamp_ord. ---! @param input eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.timestamp_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.timestamp_ord. ---! @param state eql_v3.timestamp_ord ---! @param value eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) -RETURNS eql_v3.timestamp_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.timestamp_ord. ---! @param input eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.timestamp_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_operators.sql ---! @brief Operators for eql_v3.timestamp. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_eq_operators.sql ---! @brief Operators for eql_v3.timestamp_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_search_aggregates.sql ---! @brief Aggregates for eql_v3.text_search. - ---! @brief State function for min on eql_v3.text_search. ---! @param state eql_v3.text_search ---! @param value eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_search, value eql_v3.text_search) -RETURNS eql_v3.text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.text_search. ---! @param input eql_v3.text_search ---! @return eql_v3.text_search -CREATE AGGREGATE eql_v3.min(eql_v3.text_search) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_search, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.text_search. ---! @param state eql_v3.text_search ---! @param value eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_search, value eql_v3.text_search) -RETURNS eql_v3.text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.text_search. ---! @param input eql_v3.text_search ---! @return eql_v3.text_search -CREATE AGGREGATE eql_v3.max(eql_v3.text_search) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_search, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.text_ord_ore. - ---! @brief State function for min on eql_v3.text_ord_ore. ---! @param state eql_v3.text_ord_ore ---! @param value eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.text_ord_ore. ---! @param input eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.text_ord_ore. ---! @param state eql_v3.text_ord_ore ---! @param value eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.text_ord_ore. ---! @param input eql_v3.text_ord_ore ---! @return eql_v3.text_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.text_ord_ope. - ---! @brief State function for min on eql_v3.text_ord_ope. ---! @param state eql_v3.text_ord_ope ---! @param value eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) -RETURNS eql_v3.text_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.text_ord_ope. ---! @param input eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.text_ord_ope. ---! @param state eql_v3.text_ord_ope ---! @param value eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) -RETURNS eql_v3.text_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.text_ord_ope. ---! @param input eql_v3.text_ord_ope ---! @return eql_v3.text_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_aggregates.sql ---! @brief Aggregates for eql_v3.text_ord. - ---! @brief State function for min on eql_v3.text_ord. ---! @param state eql_v3.text_ord ---! @param value eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) -RETURNS eql_v3.text_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.text_ord. ---! @param input eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE AGGREGATE eql_v3.min(eql_v3.text_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.text_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.text_ord. ---! @param state eql_v3.text_ord ---! @param value eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) -RETURNS eql_v3.text_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.text_ord. ---! @param input eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE AGGREGATE eql_v3.max(eql_v3.text_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.text_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_operators.sql ---! @brief Operators for eql_v3.text. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_match_operators.sql ---! @brief Operators for eql_v3.text_match. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_match, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_match, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_match, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_eq_operators.sql ---! @brief Operators for eql_v3.text_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.text_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.smallint_ord_ore. - ---! @brief State function for min on eql_v3.smallint_ord_ore. ---! @param state eql_v3.smallint_ord_ore ---! @param value eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) -RETURNS eql_v3.smallint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.smallint_ord_ore. ---! @param input eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.smallint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.smallint_ord_ore. ---! @param state eql_v3.smallint_ord_ore ---! @param value eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) -RETURNS eql_v3.smallint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.smallint_ord_ore. ---! @param input eql_v3.smallint_ord_ore ---! @return eql_v3.smallint_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.smallint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.smallint_ord_ope. - ---! @brief State function for min on eql_v3.smallint_ord_ope. ---! @param state eql_v3.smallint_ord_ope ---! @param value eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) -RETURNS eql_v3.smallint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.smallint_ord_ope. ---! @param input eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.smallint_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.smallint_ord_ope. ---! @param state eql_v3.smallint_ord_ope ---! @param value eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) -RETURNS eql_v3.smallint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.smallint_ord_ope. ---! @param input eql_v3.smallint_ord_ope ---! @return eql_v3.smallint_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.smallint_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_aggregates.sql ---! @brief Aggregates for eql_v3.smallint_ord. - ---! @brief State function for min on eql_v3.smallint_ord. ---! @param state eql_v3.smallint_ord ---! @param value eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) -RETURNS eql_v3.smallint_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.smallint_ord. ---! @param input eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.smallint_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.smallint_ord. ---! @param state eql_v3.smallint_ord ---! @param value eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) -RETURNS eql_v3.smallint_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.smallint_ord. ---! @param input eql_v3.smallint_ord ---! @return eql_v3.smallint_ord -CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.smallint_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_operators.sql ---! @brief Operators for eql_v3.smallint. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_eq_operators.sql ---! @brief Operators for eql_v3.smallint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.real_ord_ore. - ---! @brief State function for min on eql_v3.real_ord_ore. ---! @param state eql_v3.real_ord_ore ---! @param value eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) -RETURNS eql_v3.real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.real_ord_ore. ---! @param input eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.real_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.real_ord_ore. ---! @param state eql_v3.real_ord_ore ---! @param value eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) -RETURNS eql_v3.real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.real_ord_ore. ---! @param input eql_v3.real_ord_ore ---! @return eql_v3.real_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.real_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.real_ord_ope. - ---! @brief State function for min on eql_v3.real_ord_ope. ---! @param state eql_v3.real_ord_ope ---! @param value eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) -RETURNS eql_v3.real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.real_ord_ope. ---! @param input eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.real_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.real_ord_ope. ---! @param state eql_v3.real_ord_ope ---! @param value eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) -RETURNS eql_v3.real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.real_ord_ope. ---! @param input eql_v3.real_ord_ope ---! @return eql_v3.real_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.real_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_aggregates.sql ---! @brief Aggregates for eql_v3.real_ord. - ---! @brief State function for min on eql_v3.real_ord. ---! @param state eql_v3.real_ord ---! @param value eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) -RETURNS eql_v3.real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.real_ord. ---! @param input eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE AGGREGATE eql_v3.min(eql_v3.real_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.real_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.real_ord. ---! @param state eql_v3.real_ord ---! @param value eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) -RETURNS eql_v3.real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.real_ord. ---! @param input eql_v3.real_ord ---! @return eql_v3.real_ord -CREATE AGGREGATE eql_v3.max(eql_v3.real_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.real_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_operators.sql ---! @brief Operators for eql_v3.real. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_eq_operators.sql ---! @brief Operators for eql_v3.real_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.real_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.real_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.real_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.real_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.numeric_ord_ore. - ---! @brief State function for min on eql_v3.numeric_ord_ore. ---! @param state eql_v3.numeric_ord_ore ---! @param value eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) -RETURNS eql_v3.numeric_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.numeric_ord_ore. ---! @param input eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.numeric_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.numeric_ord_ore. ---! @param state eql_v3.numeric_ord_ore ---! @param value eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) -RETURNS eql_v3.numeric_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.numeric_ord_ore. ---! @param input eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.numeric_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.numeric_ord_ope. - ---! @brief State function for min on eql_v3.numeric_ord_ope. ---! @param state eql_v3.numeric_ord_ope ---! @param value eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) -RETURNS eql_v3.numeric_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.numeric_ord_ope. ---! @param input eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.numeric_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.numeric_ord_ope. ---! @param state eql_v3.numeric_ord_ope ---! @param value eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) -RETURNS eql_v3.numeric_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.numeric_ord_ope. ---! @param input eql_v3.numeric_ord_ope ---! @return eql_v3.numeric_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.numeric_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_aggregates.sql ---! @brief Aggregates for eql_v3.numeric_ord. - ---! @brief State function for min on eql_v3.numeric_ord. ---! @param state eql_v3.numeric_ord ---! @param value eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) -RETURNS eql_v3.numeric_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.numeric_ord. ---! @param input eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.numeric_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.numeric_ord. ---! @param state eql_v3.numeric_ord ---! @param value eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) -RETURNS eql_v3.numeric_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.numeric_ord. ---! @param input eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.numeric_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_operators.sql ---! @brief Operators for eql_v3.numeric. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_eq_operators.sql ---! @brief Operators for eql_v3.numeric_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.integer_ord_ore. - ---! @brief State function for min on eql_v3.integer_ord_ore. ---! @param state eql_v3.integer_ord_ore ---! @param value eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) -RETURNS eql_v3.integer_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.integer_ord_ore. ---! @param input eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.integer_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.integer_ord_ore. ---! @param state eql_v3.integer_ord_ore ---! @param value eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) -RETURNS eql_v3.integer_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.integer_ord_ore. ---! @param input eql_v3.integer_ord_ore ---! @return eql_v3.integer_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.integer_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.integer_ord_ope. - ---! @brief State function for min on eql_v3.integer_ord_ope. ---! @param state eql_v3.integer_ord_ope ---! @param value eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) -RETURNS eql_v3.integer_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.integer_ord_ope. ---! @param input eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.integer_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.integer_ord_ope. ---! @param state eql_v3.integer_ord_ope ---! @param value eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) -RETURNS eql_v3.integer_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.integer_ord_ope. ---! @param input eql_v3.integer_ord_ope ---! @return eql_v3.integer_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.integer_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_aggregates.sql ---! @brief Aggregates for eql_v3.integer_ord. - ---! @brief State function for min on eql_v3.integer_ord. ---! @param state eql_v3.integer_ord ---! @param value eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) -RETURNS eql_v3.integer_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.integer_ord. ---! @param input eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.integer_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.integer_ord. ---! @param state eql_v3.integer_ord ---! @param value eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) -RETURNS eql_v3.integer_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.integer_ord. ---! @param input eql_v3.integer_ord ---! @return eql_v3.integer_ord -CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.integer_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_operators.sql ---! @brief Operators for eql_v3.integer. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_eq_operators.sql ---! @brief Operators for eql_v3.integer_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.integer_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.double_ord_ore. - ---! @brief State function for min on eql_v3.double_ord_ore. ---! @param state eql_v3.double_ord_ore ---! @param value eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) -RETURNS eql_v3.double_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.double_ord_ore. ---! @param input eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.double_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.double_ord_ore. ---! @param state eql_v3.double_ord_ore ---! @param value eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) -RETURNS eql_v3.double_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.double_ord_ore. ---! @param input eql_v3.double_ord_ore ---! @return eql_v3.double_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.double_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.double_ord_ope. - ---! @brief State function for min on eql_v3.double_ord_ope. ---! @param state eql_v3.double_ord_ope ---! @param value eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) -RETURNS eql_v3.double_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.double_ord_ope. ---! @param input eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.double_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.double_ord_ope. ---! @param state eql_v3.double_ord_ope ---! @param value eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) -RETURNS eql_v3.double_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.double_ord_ope. ---! @param input eql_v3.double_ord_ope ---! @return eql_v3.double_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.double_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_ord_aggregates.sql ---! @brief Aggregates for eql_v3.double_ord. - ---! @brief State function for min on eql_v3.double_ord. ---! @param state eql_v3.double_ord ---! @param value eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) -RETURNS eql_v3.double_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.double_ord. ---! @param input eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE AGGREGATE eql_v3.min(eql_v3.double_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.double_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.double_ord. ---! @param state eql_v3.double_ord ---! @param value eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) -RETURNS eql_v3.double_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.double_ord. ---! @param input eql_v3.double_ord ---! @return eql_v3.double_ord -CREATE AGGREGATE eql_v3.max(eql_v3.double_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.double_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_operators.sql ---! @brief Operators for eql_v3.double. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_eq_operators.sql ---! @brief Operators for eql_v3.double_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.double_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.double_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.double_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.double_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.date_ord_ore. - ---! @brief State function for min on eql_v3.date_ord_ore. ---! @param state eql_v3.date_ord_ore ---! @param value eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) -RETURNS eql_v3.date_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.date_ord_ore. ---! @param input eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.date_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.date_ord_ore. ---! @param state eql_v3.date_ord_ore ---! @param value eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) -RETURNS eql_v3.date_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.date_ord_ore. ---! @param input eql_v3.date_ord_ore ---! @return eql_v3.date_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.date_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.date_ord_ope. - ---! @brief State function for min on eql_v3.date_ord_ope. ---! @param state eql_v3.date_ord_ope ---! @param value eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) -RETURNS eql_v3.date_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.date_ord_ope. ---! @param input eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.date_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.date_ord_ope. ---! @param state eql_v3.date_ord_ope ---! @param value eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) -RETURNS eql_v3.date_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.date_ord_ope. ---! @param input eql_v3.date_ord_ope ---! @return eql_v3.date_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.date_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_aggregates.sql ---! @brief Aggregates for eql_v3.date_ord. - ---! @brief State function for min on eql_v3.date_ord. ---! @param state eql_v3.date_ord ---! @param value eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) -RETURNS eql_v3.date_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.date_ord. ---! @param input eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE AGGREGATE eql_v3.min(eql_v3.date_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.date_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.date_ord. ---! @param state eql_v3.date_ord ---! @param value eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) -RETURNS eql_v3.date_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.date_ord. ---! @param input eql_v3.date_ord ---! @return eql_v3.date_ord -CREATE AGGREGATE eql_v3.max(eql_v3.date_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.date_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_operators.sql ---! @brief Operators for eql_v3.date. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_eq_operators.sql ---! @brief Operators for eql_v3.date_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.date_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/boolean/boolean_operators.sql ---! @brief Operators for eql_v3.boolean. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.boolean, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.boolean, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.boolean, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.boolean, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.boolean, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.boolean, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.boolean, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.boolean, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.boolean -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.bigint_ord_ore. - ---! @brief State function for min on eql_v3.bigint_ord_ore. ---! @param state eql_v3.bigint_ord_ore ---! @param value eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) -RETURNS eql_v3.bigint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.bigint_ord_ore. ---! @param input eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.bigint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.bigint_ord_ore. ---! @param state eql_v3.bigint_ord_ore ---! @param value eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) -RETURNS eql_v3.bigint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.bigint_ord_ore. ---! @param input eql_v3.bigint_ord_ore ---! @return eql_v3.bigint_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.bigint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql ---! @brief Aggregates for eql_v3.bigint_ord_ope. - ---! @brief State function for min on eql_v3.bigint_ord_ope. ---! @param state eql_v3.bigint_ord_ope ---! @param value eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) -RETURNS eql_v3.bigint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.bigint_ord_ope. ---! @param input eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.bigint_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.bigint_ord_ope. ---! @param state eql_v3.bigint_ord_ope ---! @param value eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) -RETURNS eql_v3.bigint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.bigint_ord_ope. ---! @param input eql_v3.bigint_ord_ope ---! @return eql_v3.bigint_ord_ope -CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.bigint_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_aggregates.sql ---! @brief Aggregates for eql_v3.bigint_ord. - ---! @brief State function for min on eql_v3.bigint_ord. ---! @param state eql_v3.bigint_ord ---! @param value eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) -RETURNS eql_v3.bigint_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for eql_v3.bigint_ord. ---! @param input eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = eql_v3.bigint_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.bigint_ord. ---! @param state eql_v3.bigint_ord ---! @param value eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) -RETURNS eql_v3.bigint_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for eql_v3.bigint_ord. ---! @param input eql_v3.bigint_ord ---! @return eql_v3.bigint_ord -CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = eql_v3.bigint_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_operators.sql ---! @brief Operators for eql_v3.bigint. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_eq_operators.sql ---! @brief Operators for eql_v3.bigint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq -); - ---! @brief EQL lint: detect non-inlinable operator implementation functions ---! ---! Returns one row per violation found in the installed `eql_v3` surface. The ---! Postgres planner can only inline a function during index matching when: ---! ---! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined) ---! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into ---! index expressions) ---! * No `SET` clauses (e.g. `SET search_path = ...`) ---! * Not `SECURITY DEFINER` ---! * Single-statement SELECT body ---! ---! @note The single-statement SELECT body condition is **not yet checked** by ---! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE, ---! or any pre-SELECT statement will pass all four implemented checks while ---! remaining non-inlinable. Implementing the check requires walking `prosrc` ---! (or `pg_get_functiondef`); tracked as a follow-up. ---! ---! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and ---! the SEM index-term types `eql_v3_internal.ore_block_256`, `eql_v3_internal.ore_cllw`) whose ---! implementation functions fail any of these rules silently fall back to seq ---! scan when the documented functional indexes (`eql_v3.eq_term(col)`, ---! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. ---! ---! Severity: ---! `error` — fixable, blocks index matching, ship-blocking. ---! `warning` — likely-fixable, may not block matching but signals intent. ---! `info` — observational; useful for review, not a defect on its own. ---! ---! Categories: ---! `inlinability_language` — implementation function isn't `LANGUAGE sql`. ---! `inlinability_volatility` — implementation function is VOLATILE. ---! `inlinability_set_clause` — implementation function has a `SET` clause. ---! `inlinability_secdef` — implementation function is `SECURITY DEFINER`. ---! `inlinability_transitive` — implementation function is itself inlinable ---! but its body invokes a non-inlinable function ---! (depth 1; the planner can't peek through ---! that boundary). ---! `blocker_language` — encrypted-domain blocker is not LANGUAGE ---! plpgsql. The planner can inline / elide a ---! LANGUAGE sql body when the result is ---! provably unused, silently bypassing the ---! RAISE that the blocker exists to perform. ---! `blocker_strict` — encrypted-domain blocker is STRICT. ---! PostgreSQL skips the body and returns NULL ---! on NULL arguments, silently bypassing the ---! RAISE. ---! `domain_over_domain` — an `eql_v3` encrypted domain is derived from ---! another encrypted domain rather than jsonb. ---! Operators resolve against the ultimate base ---! type, so the derived domain does not ---! inherit the base domain's blocker surface. ---! `domain_opclass` — an operator class is declared FOR TYPE on an ---! `eql_v3` encrypted domain. Opclasses on ---! domains bypass operator resolution; use a ---! functional index on the extractor instead. ---! `schema_placement` — a naked composite or enum TYPE lives in the ---! public `eql_v3` schema. Internal index-term ---! types (e.g. `ore_block_256_term`) belong in ---! `eql_v3_internal`; a composite/enum in ---! `eql_v3` clutters the Supabase Table Builder ---! type picker, which the schema split exists to ---! prevent. Move it to `eql_v3_internal`. ---! ---! @example ---! ``` ---! SELECT severity, category, object_name, message ---! FROM eql_v3.lints() ---! WHERE severity = 'error' ---! ORDER BY category, object_name; ---! ``` ---! ---! @return SETOF record (severity text, category text, object_name text, message text) -CREATE OR REPLACE FUNCTION eql_v3.lints() -RETURNS TABLE ( - severity text, - category text, - object_name text, - message text -) -LANGUAGE sql STABLE -AS $$ - WITH - -- All operators where at least one operand is an `eql_v3` type. Limits - -- the scope of the lint to the operator surface customers actually hit - -- via SQL (`col = val`, `col @> '...'` and friends). - eql_operators AS ( - SELECT - op.oid AS oprid, - op.oprname AS opname, - op.oprcode AS implfunc, - op.oprleft::regtype AS lhs, - op.oprright::regtype AS rhs, - op.oprcode::regprocedure AS impl_signature - FROM pg_operator op - WHERE EXISTS ( - SELECT 1 FROM pg_type t - WHERE t.oid IN (op.oprleft, op.oprright) - AND t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) - ) - ), - - -- Cross-join with each operator's implementation function metadata. - -- One row per operator; columns describe the inlinability of the impl. - op_impl AS ( - SELECT - eo.opname, - eo.lhs, - eo.rhs, - eo.implfunc AS impl_oid, - eo.impl_signature::text AS impl_signature, - lang_l.lanname AS lang, - p.provolatile AS volatility, - p.proconfig AS config, - p.prosecdef AS secdef, - p.prosrc AS body - FROM eql_operators eo - JOIN pg_proc p ON p.oid = eo.implfunc - JOIN pg_language lang_l ON lang_l.oid = p.prolang - ), - - -- Encrypted-domain blockers: functions in `eql_v3` whose body contains - -- a blocker marker emitted by the codegen (any of the - -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean - -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the - -- literal `is not supported for` for older path-operator blockers) AND - -- that take at least one `eql_v3` domain over jsonb argument. The argument - -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` - -- helpers themselves, which contain the marker in their body but are not - -- blockers (they take text arguments, not a domain). - encrypted_domain_blockers AS ( - SELECT - p.oid AS oid, - p.oid::regprocedure::text AS signature, - lang_l.lanname AS lang, - p.proisstrict AS isstrict - FROM pg_catalog.pg_proc p - JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) - AND (p.prosrc LIKE '%encrypted_domain_unsupported%' - OR p.prosrc LIKE '%is not supported for%') - AND EXISTS ( - SELECT 1 - FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) - JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - WHERE dt.typtype = 'd' - AND bt.typname = 'jsonb' - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) - ) - ) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Direct inlinability checks: each row examines one operator's │ - -- │ implementation function and emits a violation if any rule is │ - -- │ broken. Multiple violations on the same function become │ - -- │ multiple rows (developers see every reason it doesn't inline). │ - -- └─────────────────────────────────────────────────────────────────┘ - - SELECT - 'error' AS severity, - 'inlinability_language' AS category, - format('operator %s(%s, %s) -> %s', - opname, lhs, rhs, impl_signature) AS object_name, - format( - 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.', - lang, opname) AS message - FROM op_impl - WHERE lang <> 'sql' - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) - - UNION ALL - - SELECT - 'error', - 'inlinability_volatility', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).', - opname) - FROM op_impl - WHERE volatility = 'v' - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) - - UNION ALL - - SELECT - 'error', - 'inlinability_set_clause', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.') - FROM op_impl - WHERE config IS NOT NULL - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) - - UNION ALL - - SELECT - 'error', - 'inlinability_secdef', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.' - FROM op_impl - WHERE secdef - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Transitive inlinability: an operator implementation function │ - -- │ that's itself inlinable can still fail to inline if its body │ - -- │ calls a non-inlinable function. Walk one level via pg_depend. │ - -- │ │ - -- │ Postgres records function-to-function dependencies in │ - -- │ pg_depend with deptype 'n' (normal) when one function references│ - -- │ another in its body — but only at CREATE time and only for │ - -- │ direct calls. This is good enough for v1; deeper transitive │ - -- │ analysis is a follow-up. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'inlinability_transitive', - format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs, - oi.impl_signature), - format( - 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.', - called.proname, - called_lang.lanname, - CASE called.provolatile - WHEN 'i' THEN 'IMMUTABLE' - WHEN 's' THEN 'STABLE' - WHEN 'v' THEN 'VOLATILE' - END, - CASE WHEN called.proconfig IS NOT NULL - THEN ', has SET clause' - ELSE '' END) - FROM op_impl oi - -- Only worth the transitive check if the outer function is otherwise - -- inlinable — otherwise the direct lints above already report it. - JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure - JOIN pg_depend d - ON d.classid = 'pg_proc'::regclass - AND d.objid = outer_p.oid - AND d.refclassid = 'pg_proc'::regclass - AND d.deptype = 'n' - JOIN pg_proc called ON called.oid = d.refobjid - JOIN pg_language called_lang ON called_lang.oid = called.prolang - WHERE oi.lang = 'sql' - AND oi.volatility IN ('i', 's') - AND oi.config IS NULL - AND NOT oi.secdef - AND called.oid <> outer_p.oid - AND ( - called_lang.lanname <> 'sql' - OR called.provolatile = 'v' - OR called.proconfig IS NOT NULL - OR called.prosecdef - ) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │ - -- │ have inverted inlinability requirements vs operator impls. │ - -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │ - -- │ blocker returns NULL on NULL args. Both silently re-enable │ - -- │ operators the storage variant is supposed to block. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'blocker_language', - format('function %s', signature), - format( - 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.', - lang) - FROM encrypted_domain_blockers - WHERE lang <> 'plpgsql' - - UNION ALL - - SELECT - 'error', - 'blocker_strict', - format('function %s', signature), - 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.' - FROM encrypted_domain_blockers - WHERE isstrict - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain identity: an encrypted-domain must be defined directly │ - -- │ over jsonb. Operators resolve against the ultimate base type, │ - -- │ so domain-over-domain inherits jsonb's operator surface and not │ - -- │ the base domain's blockers. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'domain_over_domain', - format('domain %I.%I', dn.nspname, dt.typname), - format( - 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.', - dn.nspname, dt.typname, bn.nspname, bt.typname) - FROM pg_catalog.pg_type dt - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace - WHERE dt.typtype = 'd' - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) - AND bt.typtype = 'd' - AND bn.nspname = ANY(eql_v3_internal.owned_schemas()) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain opclass: an operator class declared FOR TYPE on an │ - -- │ encrypted-domain bypasses operator resolution at index time. │ - -- │ Use a functional index on the extractor instead. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'domain_opclass', - format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname), - format( - 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.', - cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname) - FROM pg_catalog.pg_opclass oc - JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype - JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace - JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace - WHERE t.typtype = 'd' - AND tn.nspname = ANY(eql_v3_internal.owned_schemas()) - - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Schema placement: the public `eql_v3` schema must hold only the │ - -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │ - -- │ there is an internal index-term type in the wrong schema — it │ - -- │ clutters the Supabase type picker the split exists to keep clean. │ - -- └─────────────────────────────────────────────────────────────────┘ - - UNION ALL - - SELECT - 'error', - 'schema_placement', - format('type %I.%I', n.nspname, t.typname), - format( - 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.', - n.nspname, t.typname, - CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END) - FROM pg_catalog.pg_type t - JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace - WHERE n.nspname = 'eql_v3' - AND t.typtype IN ('c', 'e') - - ORDER BY 1, 2, 3; -$$; - -COMMENT ON FUNCTION eql_v3.lints() IS - 'EQL lint: returns one row per non-inlinable operator implementation. ' - 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a ' - 'CI-gateable check that all operator implementations on eql_v3 types are ' - 'eligible for planner inlining.'; - ---! @file v3/jsonb/operators.sql ---! @brief Operators on eql_v3.json and eql_v3.jsonb_entry. - ------------------------------------------------------------------------------- --- -> field accessor (returns jsonb_entry) ------------------------------------------------------------------------------- - ---! @brief -> operator with text selector. ---! ---! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged ---! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to ---! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional ---! index on `eql_v3.eq_term(col -> 'sel')`. ---! ---! @warning The selector operand MUST carry a known type — a text-typed ---! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::text`). ---! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> text` ---! operator and silently returns native jsonb semantics (a root-key lookup, ---! typically NULL), NOT this operator: PostgreSQL reduces the `eql_v3.json` ---! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the ---! native base-type operator wins the exact-match tiebreak. This is intrinsic to ---! the domain type-kind and applies to the native-jsonb blockers too. See ---! the "Typed operands" caveat in docs/reference/json-support.md. ---! ---! @param e eql_v3.json Root encrypted payload. ---! @param selector text Selector hash. ---! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector text) - RETURNS eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT ( - eql_v3.meta_data(e) || - jsonb_path_query_first( - e, - '$.sv[*] ? (@.s == $sel)'::jsonpath, - jsonb_build_object('sel', selector) - ) - )::eql_v3.jsonb_entry -$$; - -CREATE OPERATOR ->( - FUNCTION=eql_v3."->", - LEFTARG=eql_v3.json, - RIGHTARG=text -); - ---! @brief -> operator with integer array index (0-based, JSONB convention). ---! @param e eql_v3.json Encrypted sv-array payload. ---! @param selector integer Array index. ---! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector integer) - RETURNS eql_v3.jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE - WHEN eql_v3_internal.is_ste_vec_array(e) THEN - -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an - -- unknown-typed literal, so `e -> 'sv'` already flattens `eql_v3.json` to - -- its base type and binds native `jsonb -> text` (see the @warning above) — - -- the custom `->(eql_v3.json, text)` operator does NOT capture a bare - -- untyped literal. The cast documents that intent and guards the `-> selector` - -- (integer) hop from ever resolving to the v3 `->(eql_v3.json, integer)` - -- operator instead of native array access. - (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::eql_v3.jsonb_entry - ELSE NULL - END -$$; - -CREATE OPERATOR ->( - FUNCTION=eql_v3."->", - LEFTARG=eql_v3.json, - RIGHTARG=integer -); - ------------------------------------------------------------------------------- --- ->> field accessor (alias of -> coerced to text) ------------------------------------------------------------------------------- - ---! @brief ->> operator with text selector. Inlinable alias of -> coerced to ---! text. ---! ---! Intentional v2 parity: this serializes the entire matched jsonb_entry ---! object as JSON text. It does not decrypt or return scalar plaintext like ---! native `jsonb ->>`. ---! @param e eql_v3.json Encrypted payload. ---! @param selector text Field selector hash. ---! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector text) - RETURNS text - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3."->"(e, selector)::jsonb::text -$$; - -CREATE OPERATOR ->> ( - FUNCTION=eql_v3."->>", - LEFTARG=eql_v3.json, - RIGHTARG=text -); - ---! @brief ->> operator with integer array index. Inlinable alias of ---! ->(json, integer) coerced to text. ---! @param e eql_v3.json Encrypted sv-array payload. ---! @param selector integer Array index. ---! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector integer) - RETURNS text - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3."->"(e, selector)::jsonb::text -$$; - -CREATE OPERATOR ->> ( - FUNCTION=eql_v3."->>", - LEFTARG=eql_v3.json, - RIGHTARG=integer -); - ------------------------------------------------------------------------------- --- @> containment ------------------------------------------------------------------------------- - ---! @brief @> contains operator (document, document). ---! @param a eql_v3.json Container. ---! @param b eql_v3.json Contained value. ---! @return boolean True if a contains b. ---! @see eql_v3.ste_vec_contains -CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.json) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ste_vec_contains(a, b) -$$; - -CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.json -); - ---! @brief @> contains operator with an jsonb_query needle. ---! ---! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a ---! functional GIN index on the same expression engages. ---! ---! @param a eql_v3.json Container. ---! @param b eql_v3.jsonb_query Query payload. ---! @return boolean True if a contains b. -CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_query) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb -$$; - -CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.jsonb_query -); - ---! @brief @> contains operator with a single jsonb_entry needle. ---! ---! Wraps the entry into a single-element sv array (stripping `c`) and reduces ---! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form. ---! ---! @param a eql_v3.json Container. ---! @param b eql_v3.jsonb_entry Single entry. ---! @return boolean True if a contains an sv entry matching b. -CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_entry) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.to_ste_vec_query(a)::jsonb - @> jsonb_build_object( - 'sv', - jsonb_build_array( - jsonb_strip_nulls( - jsonb_build_object( - 's', b -> 's', - 'hm', b -> 'hm', - 'oc', b -> 'oc' - ) - ) - ) - ) -$$; - -CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.jsonb_entry -); - ------------------------------------------------------------------------------- --- <@ contained-by (reverse of @>) ------------------------------------------------------------------------------- - ---! @brief <@ contained-by operator (document, document). ---! @param a eql_v3.json Contained value. ---! @param b eql_v3.json Container. ---! @return boolean True if a is contained by b. -CREATE FUNCTION eql_v3."<@"(a eql_v3.json, b eql_v3.json) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ste_vec_contains(b, a) -$$; - -CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.json -); - ---! @brief <@ contained-by operator with an jsonb_query LHS. ---! @param a eql_v3.jsonb_query Query payload. ---! @param b eql_v3.json Container. ---! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_query, b eql_v3.json) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3."@>"(b, a) -$$; - -CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.jsonb_query, - RIGHTARG=eql_v3.json -); - ---! @brief <@ contained-by operator with a jsonb_entry LHS. ---! @param a eql_v3.jsonb_entry Single entry. ---! @param b eql_v3.json Container. ---! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_entry, b eql_v3.json) -RETURNS boolean -LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3."@>"(b, a) -$$; - -CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.jsonb_entry, - RIGHTARG=eql_v3.json -); - ------------------------------------------------------------------------------- --- jsonb_entry comparisons ------------------------------------------------------------------------------- - ---! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if the entries are equal -CREATE FUNCTION eql_v3.eq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) -$$; - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = =, - NEGATOR = <>, - RESTRICT = eqsel, - JOIN = eqjoinsel -); - ---! @brief Inequality on jsonb_entry via eq_term. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if the entries are not equal -CREATE FUNCTION eql_v3.neq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) -$$; - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = <>, - NEGATOR = =, - RESTRICT = neqsel, - JOIN = neqjoinsel -); - ---! @brief Less-than on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if a is less than b -CREATE FUNCTION eql_v3.lt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ore_cllw(a) < eql_v3.ore_cllw(b) -$$; - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = >, - NEGATOR = >=, - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel -); - ---! @brief Less-than-or-equal on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if a is less than or equal to b -CREATE FUNCTION eql_v3.lte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ore_cllw(a) <= eql_v3.ore_cllw(b) -$$; - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = >=, - NEGATOR = >, - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel -); - ---! @brief Greater-than on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if a is greater than b -CREATE FUNCTION eql_v3.gt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ore_cllw(a) > eql_v3.ore_cllw(b) -$$; - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = <, - NEGATOR = <=, - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel -); - ---! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. ---! @param a eql_v3.jsonb_entry Left operand ---! @param b eql_v3.jsonb_entry Right operand ---! @return boolean True if a is greater than or equal to b -CREATE FUNCTION eql_v3.gte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.ore_cllw(a) >= eql_v3.ore_cllw(b) -$$; - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = <=, - NEGATOR = <, - RESTRICT = scalargesel, - JOIN = scalargejoinsel -); - ---! @file v3/jsonb/blockers.sql ---! @brief Native-jsonb firewall for eql_v3.json. ---! ---! eql_v3.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons ---! = <> < <= > >= are supported on eql_v3.jsonb_entry only, not on the root ---! document domain. ---! Every OTHER native jsonb operator reachable via domain fallback against the ---! base type jsonb is BLOCKED here so an encrypted column can never silently ---! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS ---! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||. ---! ---! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let ---! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the ---! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_* ---! helpers. Each blocker's RETURNS type matches the native operator it shadows ---! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a ---! composed expression resolves and the body raises 'operator not supported', ---! rather than failing earlier with a misleading 'operator does not exist' on a ---! boolean intermediate. The bound operator must resolve before native fallback, ---! so the firewall fires. - ---! @brief Blocker: ? (key/element exists). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a eql_v3.json, b text) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal.jsonb_blocked_exists, - LEFTARG = eql_v3.json, - RIGHTARG = text -); - ---! @brief Blocker: ?| (any key exists). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a eql_v3.json, b text[]) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?|'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: ?& (all keys exist). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a eql_v3.json, b text[]) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?&'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: @? (jsonpath exists). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonpath Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a eql_v3.json, b jsonpath) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@?'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, - LEFTARG = eql_v3.json, - RIGHTARG = jsonpath -); - ---! @brief Blocker: @@ (jsonpath predicate). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonpath Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a eql_v3.json, b jsonpath) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@@'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, - LEFTARG = eql_v3.json, - RIGHTARG = jsonpath -); - ---! @brief Blocker: #> (path extract, native returns jsonb). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a eql_v3.json, b text[]) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#>'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: #>> (path extract as text). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return text Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a eql_v3.json, b text[]) -RETURNS text -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_text('eql_v3.json', '#>>'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: - (delete key, text RHS; native returns jsonb). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a eql_v3.json, b text) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, - LEFTARG = eql_v3.json, - RIGHTARG = text -); - ---! @brief Blocker: - (delete index, integer RHS). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b integer Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a eql_v3.json, b integer) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, - LEFTARG = eql_v3.json, - RIGHTARG = integer -); - ---! @brief Blocker: - (delete keys, text[] RHS). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a eql_v3.json, b text[]) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: #- (delete at path). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b text[] Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a eql_v3.json, b text[]) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#-'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, - LEFTARG = eql_v3.json, - RIGHTARG = text[] -); - ---! @brief Blocker: || (concatenate, encrypted on the left). ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonb Native RHS operand. ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a eql_v3.json, b jsonb) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal.jsonb_blocked_concat, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - ---! @brief Blocker: || (concatenate, encrypted on the right). ---! @param a jsonb Native LHS operand. ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b eql_v3.json) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - ------------------------------------------------------------------------------- --- Root-document comparison blockers. ------------------------------------------------------------------------------- - ---! @brief Blocker: root eql_v3.json document comparisons. ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a eql_v3.json, b eql_v3.json) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: root eql_v3.json-to-jsonb comparisons. ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonb Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a eql_v3.json, b jsonb) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: root jsonb-to-eql_v3.json comparisons. ---! @param a jsonb Native LHS operand. ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b eql_v3.json) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - ------------------------------------------------------------------------------- --- Mixed jsonb containment blockers. ------------------------------------------------------------------------------- - ---! @brief Blocker: @> with encrypted root document and native jsonb. ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonb Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a eql_v3.json, b jsonb) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: @> with native jsonb and encrypted root document. ---! @param a jsonb Native LHS operand. ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b eql_v3.json) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: <@ with encrypted root document and native jsonb. ---! @param a eql_v3.json Left operand (encrypted payload). ---! @param b jsonb Native RHS operand. ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a eql_v3.json, b jsonb) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); -END; -$$ LANGUAGE plpgsql; - ---! @brief Blocker: <@ with native jsonb and encrypted root document. ---! @param a jsonb Native LHS operand. ---! @param b eql_v3.json Right operand (encrypted payload). ---! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b eql_v3.json) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); -END; -$$ LANGUAGE plpgsql; - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - ---! @file v3/jsonb/aggregates.sql ---! @brief min / max aggregates over eql_v3.jsonb_entry. ---! ---! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by ---! their CLLW ORE (`oc`) term, so the extremum is picked by comparing ---! `eql_v3.ore_cllw(entry)` rather than the scalar Block-ORE `ord_term` the ---! generated scalar ord aggregates use. Same STRICT + PARALLEL SAFE shape as the ---! generated scalar `min`/`max` so partial/parallel aggregation is available on ---! large GROUP BY workloads. ---! ---! Per the encrypted-domain footgun rules the state functions are ---! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would ---! be inlinable and the planner could elide it. ---! ---! @note **Only `oc`-carrying entries are orderable.** `eql_v3.ore_cllw(entry)` ---! returns NULL when an entry has no `oc` (CLLW ORE) term — the same entries a ---! `eql_v3.ore_cllw` btree NULL-filters from range scans. The state functions ---! therefore IGNORE `oc`-less entries (they never become or survive as the ---! extremum), so `min`/`max` is well-defined over a mix of `oc`-carrying and ---! `oc`-less entries and is not corrupted by an `oc`-less seed. A naive ---! `ore_cllw(value) < ore_cllw(state)` would be NULL whenever either side ---! lacks `oc`, pinning a wrong (`oc`-less) extremum when the first aggregated ---! row is `oc`-less. An all-`oc`-less input has no orderable extremum and ---! returns the (arbitrary) STRICT seed. - ---! @brief State function for min on eql_v3.jsonb_entry. ---! ---! Keeps whichever orderable entry has the lesser CLLW ORE term. STRICT, so SQL ---! NULL entries are skipped by the aggregate machinery; `oc`-less (non-orderable) ---! entries are skipped explicitly (see the @note on this file). ---! ---! @param state eql_v3.jsonb_entry Running extremum. ---! @param value eql_v3.jsonb_entry Candidate entry. ---! @return eql_v3.jsonb_entry The lesser orderable entry by `ore_cllw`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( - state eql_v3.jsonb_entry, - value eql_v3.jsonb_entry -) -RETURNS eql_v3.jsonb_entry -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); - state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); -BEGIN - -- A non-orderable (oc-less) candidate never replaces the running extremum. - IF value_ore IS NULL THEN - RETURN state; - END IF; - -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an oc-less STRICT seed) or strictly greater. - IF state_ore IS NULL OR value_ore < state_ore THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate over eql_v3.jsonb_entry. ---! @param input eql_v3.jsonb_entry ---! @return eql_v3.jsonb_entry The entry with the smallest CLLW ORE term. -CREATE AGGREGATE eql_v3.min(eql_v3.jsonb_entry) ( - sfunc = eql_v3_internal.jsonb_entry_min_sfunc, - stype = eql_v3.jsonb_entry, - combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.jsonb_entry. ---! ---! Keeps whichever orderable entry has the greater CLLW ORE term. `oc`-less ---! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). ---! ---! @param state eql_v3.jsonb_entry Running extremum. ---! @param value eql_v3.jsonb_entry Candidate entry. ---! @return eql_v3.jsonb_entry The greater orderable entry by `ore_cllw`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( - state eql_v3.jsonb_entry, - value eql_v3.jsonb_entry -) -RETURNS eql_v3.jsonb_entry -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); - state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); -BEGIN - -- A non-orderable (oc-less) candidate never replaces the running extremum. - IF value_ore IS NULL THEN - RETURN state; - END IF; - -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an oc-less STRICT seed) or strictly lesser. - IF state_ore IS NULL OR value_ore > state_ore THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate over eql_v3.jsonb_entry. ---! @param input eql_v3.jsonb_entry ---! @return eql_v3.jsonb_entry The entry with the largest CLLW ORE term. -CREATE AGGREGATE eql_v3.max(eql_v3.jsonb_entry) ( - sfunc = eql_v3_internal.jsonb_entry_max_sfunc, - stype = eql_v3.jsonb_entry, - combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, - parallel = safe -); ---! @file pin_search_path_v3.sql ---! @brief Post-install: pin search_path on every eql_v3.* function. ---! ---! Appended verbatim by `tasks/build.sh` to the end of the v3-only release ---! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives ---! outside src/ so it stays out of the dependency graph. ---! ---! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and ---! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`, ---! satisfying Supabase splinter's `function_search_path_mutable` lint. ---! ---! @note A SET clause disables SQL-function inlining. The inline-critical SEM ---! helpers (ore_block_256_*, ore_cllw_*, ore_cllw/has_ore_cllw, ---! ope_cllw, hmac_256, bloom_filter over jsonb) and the ---! encrypted-domain family (recognised structurally) are deliberately ---! left unpinned. ---! @see tasks/test/splinter.sh ---! @see tasks/build.sh - -DO $$ -DECLARE - fn_oid oid; - inline_critical_oids oid[]; - jsonb_oid oid; -BEGIN - SELECT t.oid INTO jsonb_oid - FROM pg_catalog.pg_type t - JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace - WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb'; - - IF jsonb_oid IS NULL THEN - RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found'; - END IF; - - -- eql_v3 SEM index-term functions that must stay inlinable for - -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause - -- in the legacy combined pin_search_path.sql. - SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids - FROM pg_catalog.pg_proc p - JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) - AND ( - (p.pronargs = 2 - AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq', - 'ore_block_256_lt', 'ore_block_256_lte', - 'ore_block_256_gt', 'ore_block_256_gte')) - OR (p.pronargs = 2 - AND p.proname IN ('ore_cllw_eq', 'ore_cllw_neq', - 'ore_cllw_lt', 'ore_cllw_lte', - 'ore_cllw_gt', 'ore_cllw_gte')) - OR (p.pronargs = 1 - AND p.proname IN ('ore_cllw', 'has_ore_cllw') - AND p.proargtypes[0] = jsonb_oid) - -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a - -- domain over bytea (native comparison operators and btree opclass), - -- so there are no ope-specific comparison functions to keep inlinable. - OR (p.pronargs = 1 - AND p.proname = 'ope_cllw' - AND p.proargtypes[0] = jsonb_oid) - OR (p.pronargs = 1 - AND p.proname = 'hmac_256' - AND p.proargtypes[0] = jsonb_oid) - OR (p.pronargs = 1 - AND p.proname = 'bloom_filter' - AND p.proargtypes[0] = jsonb_oid) - ); - - FOR fn_oid IN - SELECT p.oid - FROM pg_catalog.pg_proc p - JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) - AND p.prokind IN ('f', 'w') - AND NOT EXISTS ( - SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c - WHERE c LIKE 'search_path=%' - ) - AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[]))) - -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE, - -- taking >=1 argument typed as a jsonb-backed DOMAIN in eql_v3. - AND NOT ( - p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l - WHERE l.lanname = 'sql') - AND p.provolatile = 'i' - AND EXISTS ( - SELECT 1 - FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) - JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - WHERE dt.typtype = 'd' - AND dt.typbasetype = jsonb_oid - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) - ) - ) - -- Comment-marker fallback for hand-written inline-critical extension - -- functions that take no domain argument. - AND NOT EXISTS ( - SELECT 1 FROM pg_catalog.pg_description d - WHERE d.objoid = p.oid - AND d.classoid = 'pg_catalog.pg_proc'::regclass - AND d.description LIKE 'eql-inline-critical%' - ) - LOOP - EXECUTE pg_catalog.format( - 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public', - fn_oid::regprocedure - ); - END LOOP; -END $$; diff --git a/packages/stack/__tests__/helpers/eql-v3.ts b/packages/stack/__tests__/helpers/eql-v3.ts deleted file mode 100644 index bfb8fb556..000000000 --- a/packages/stack/__tests__/helpers/eql-v3.ts +++ /dev/null @@ -1,161 +0,0 @@ -import { readFile } from 'node:fs/promises' -import { dirname, resolve } from 'node:path' -import { fileURLToPath } from 'node:url' -import type postgres from 'postgres' - -const EQL_V3_ADVISORY_LOCK_ID = 3_733_003 - -const helperDir = dirname(fileURLToPath(import.meta.url)) -// The upstream `eql-3.0.0-alpha.2` release artifact (cipherstash-encrypt.sql -// from cipherstash/encrypt-query-language), vendored byte-for-byte. -const eqlV3SqlPath = resolve( - helperDir, - '../fixtures/eql-v3/cipherstash-encrypt-v3.sql', -) -// The CLI-vendored Supabase variant (opclass chunks stripped by -// packages/cli/scripts/build-eql-v3-sql.mjs from the fixture above; CI keeps -// the two in sync). Upstream ships no Supabase variant for v3 yet, so it is -// still derived locally. Reading the shipped artifact instead of re-stripping -// here means the live Supabase suite installs exactly what -// `stash eql install --eql-version 3 --supabase` installs. -const eqlV3SupabaseSqlPath = resolve( - helperDir, - '../../../cli/src/sql/cipherstash-encrypt-v3-supabase.sql', -) - -/** - * The `eql_v3` + `eql_v3_internal` grants for the Supabase roles. Mirrors the - * CLI's `supabasePermissionsSql('eql_v3')` (packages/cli/src/installer) — - * inlined rather than imported because the stack package cannot resolve the - * cli package's dependency graph (pg) from its test context. - * - * eql_v3_internal needs the same grants: the eql_v3 operators/domain CHECKs - * call into SECURITY INVOKER functions and composite types there (SEM - * index-term internals split out in eql-3.0.0-alpha.2), so without - * USAGE/EXECUTE on eql_v3_internal every anon/authenticated encrypted query - * fails 42501. Note: Supabase "Exposed schemas" must remain eql_v3 ONLY — - * granting on eql_v3_internal does not (and must not) expose it via PostgREST. - */ -const EQL_V3_SUPABASE_GRANTS = ` - GRANT USAGE ON SCHEMA eql_v3 TO anon, authenticated, service_role; - GRANT SELECT ON ALL TABLES IN SCHEMA eql_v3 TO anon, authenticated, service_role; - GRANT EXECUTE ON ALL ROUTINES IN SCHEMA eql_v3 TO anon, authenticated, service_role; - GRANT USAGE ON ALL SEQUENCES IN SCHEMA eql_v3 TO anon, authenticated, service_role; - ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3 GRANT SELECT ON TABLES TO anon, authenticated, service_role; - ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3 GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; - ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3 GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; - GRANT USAGE ON SCHEMA eql_v3_internal TO anon, authenticated, service_role; - GRANT SELECT ON ALL TABLES IN SCHEMA eql_v3_internal TO anon, authenticated, service_role; - GRANT EXECUTE ON ALL ROUTINES IN SCHEMA eql_v3_internal TO anon, authenticated, service_role; - GRANT USAGE ON ALL SEQUENCES IN SCHEMA eql_v3_internal TO anon, authenticated, service_role; - ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3_internal GRANT SELECT ON TABLES TO anon, authenticated, service_role; - ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3_internal GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; - ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3_internal GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; -` - -/** - * Generation-aware install sentinel. `to_regtype('eql_v3.text_search')` alone - * is NOT enough: text_search exists in both the pre-alpha.2 snapshot and the - * current bundle, so a stale old-generation install would be silently reused. - * The eql_v3_internal schema and the SQL-standard-renamed eql_v3.timestamp - * domain only exist in the eql-3.0.0-alpha.2 generation, so requiring them - * distinguishes current from stale. - */ -async function hasCurrentGenerationEqlV3(sql: postgres.Sql): Promise { - const [row] = await sql<{ installed: boolean }[]>` - SELECT - to_regtype('eql_v3.text_search') IS NOT NULL - AND to_regtype('eql_v3.timestamp') IS NOT NULL - AND EXISTS ( - SELECT 1 FROM pg_namespace WHERE nspname = 'eql_v3_internal' - ) AS installed - ` - return row?.installed ?? false -} - -/** - * Install the vendored EQL v3 SQL bundle (eql-3.0.0-alpha.2) only when the - * target database does not already have a current-generation install. - * - * The bundle starts with DROP SCHEMA IF EXISTS eql_v3 CASCADE (and drops - * eql_v3_internal too), so callers must never run it unconditionally against - * a shared test database. - * - * Pass `supabase: true` when targeting a Supabase database: the operator - * class/family chunks are stripped (they need superuser) and the `eql_v3` and - * `eql_v3_internal` schemas are granted to the Supabase roles, mirroring the - * CLI's `--eql-version 3 --supabase` install. - */ -export async function installEqlV3IfNeeded( - sql: postgres.Sql, - options?: { supabase?: boolean }, -): Promise { - // Advisory locks are session-scoped, so the whole check/install/unlock flow - // must run on a single reserved connection. Issuing the lock/unlock via the - // pool can land them on different pooled backends — allowing an install race - // and unlocking a backend that never held the lock. - const reserved = await sql.reserve() - - try { - await reserved`SELECT pg_advisory_lock(${EQL_V3_ADVISORY_LOCK_ID})` - - try { - if (await hasCurrentGenerationEqlV3(reserved)) return - - // Reaching here means either nothing is installed, or a STALE - // previous-generation install is present (eql_v3 exists — e.g. - // eql_v3.text_search resolves — but the eql_v3_internal schema / - // renamed domains are absent). Either way, re-run the bundle: it opens - // with DROP SCHEMA IF EXISTS eql_v3 CASCADE and DROP SCHEMA IF EXISTS - // eql_v3_internal CASCADE, so the stale install is replaced wholesale. - // Belt-and-braces: drop eql_v3_internal explicitly first so the - // reinstall stays idempotent even if a future bundle stops dropping it. - await reserved`DROP SCHEMA IF EXISTS eql_v3_internal CASCADE` - - const eqlV3Sql = await readFile( - options?.supabase ? eqlV3SupabaseSqlPath : eqlV3SqlPath, - 'utf8', - ) - await reserved.unsafe(eqlV3Sql) - - if (options?.supabase) { - // The Supabase roles don't own the schemas; without these grants every - // encrypted query fails 42501 over PostgREST. - await reserved.unsafe(EQL_V3_SUPABASE_GRANTS) - } - - if (!(await hasCurrentGenerationEqlV3(reserved))) { - throw new Error( - 'EQL v3 installation did not create the current-generation eql_v3 surface (eql_v3.text_search, eql_v3.timestamp, eql_v3_internal)', - ) - } - } finally { - await reserved`SELECT pg_advisory_unlock(${EQL_V3_ADVISORY_LOCK_ID})` - } - } finally { - reserved.release() - } -} - -/** - * Version-handshake guard for the live suites: assert that a payload the - * client just produced is a v:3-wire envelope matching the installed bundle's - * domain CHECK pins (`VALUE->>'v' = '3'`, eql-3.0.0-alpha.2). A mismatch means - * generation skew — a stale protect-ffi pin, missing `eqlVersion: 3` wiring, - * or a stale vendored bundle — exactly the drift class that previously went - * unnoticed (PR #547 originally wrote v2-wire data against v:2 CHECK pins). - * Fail loudly and name the skew instead of letting inserts fail with an - * opaque 23514 (or, worse, a mismatched bundle silently accept them). - */ -export function assertV3WireEnvelope(payload: unknown, context: string): void { - const v = - typeof payload === 'object' && payload !== null - ? (payload as Record).v - : undefined - if (v !== 3) { - throw new Error( - `EQL generation skew (${context}): client emitted an envelope with v=${JSON.stringify(v)} but the installed eql_v3 bundle (eql-3.0.0-alpha.2) pins v='3'. ` + - 'Check the @cipherstash/protect-ffi version (needs >= 0.27.0), the eqlVersion wiring (EncryptionV3 / Encryption auto-detection), and the vendored bundle generation.', - ) - } -} diff --git a/packages/stack/__tests__/helpers/live-gate.ts b/packages/stack/__tests__/helpers/live-gate.ts deleted file mode 100644 index 8ad3675ec..000000000 --- a/packages/stack/__tests__/helpers/live-gate.ts +++ /dev/null @@ -1,28 +0,0 @@ -import { describe } from 'vitest' - -/** - * Shared env gates for the live (network-touching) suites. Previously each - * live suite re-declared these; one definition keeps the credential list — - * and therefore what "live" means — from drifting between files. - * - * Callers must `import 'dotenv/config'` BEFORE importing this module (all - * live suites already do, as their first import) so the env is populated - * when these are evaluated. - */ - -/** True when live CipherStash (ZeroKMS/CTS) credentials are configured. */ -export const LIVE_CIPHERSTASH_ENABLED = Boolean( - process.env.CS_WORKSPACE_CRN && - process.env.CS_CLIENT_ID && - process.env.CS_CLIENT_KEY && - process.env.CS_CLIENT_ACCESS_KEY, -) - -/** True when live credentials AND a Postgres `DATABASE_URL` are configured. */ -export const LIVE_EQL_V3_PG_ENABLED = Boolean( - process.env.DATABASE_URL && LIVE_CIPHERSTASH_ENABLED, -) - -export const describeLive = LIVE_CIPHERSTASH_ENABLED ? describe : describe.skip - -export const describeLivePg = LIVE_EQL_V3_PG_ENABLED ? describe : describe.skip diff --git a/packages/stack/__tests__/init-strategy.test.ts b/packages/stack/__tests__/init-strategy.test.ts index 857885572..e92e05da1 100644 --- a/packages/stack/__tests__/init-strategy.test.ts +++ b/packages/stack/__tests__/init-strategy.test.ts @@ -244,12 +244,15 @@ describe('Encryption config.eqlVersion', () => { expect(lastNewClientOpts().eqlVersion).toBe(3) }) - it('EncryptionV3 honours an explicit eqlVersion override', async () => { + it('EncryptionV3 overrides an explicit eqlVersion — v3 is an invariant', async () => { + // A v2-mode client cannot resolve v3 concrete-type columns (every encrypt + // fails inside the FFI), so EncryptionV3 pins the wire format rather than + // honouring a caller's eqlVersion. await EncryptionV3({ schemas: [v3Table() as never], config: { eqlVersion: 2 }, }) - expect(lastNewClientOpts().eqlVersion).toBe(2) + expect(lastNewClientOpts().eqlVersion).toBe(3) }) }) diff --git a/packages/stack/__tests__/lock-context.test.ts b/packages/stack/__tests__/lock-context.test.ts index fd45797ac..922d2c67c 100644 --- a/packages/stack/__tests__/lock-context.test.ts +++ b/packages/stack/__tests__/lock-context.test.ts @@ -123,12 +123,26 @@ describe('identity-bound encryption via OidcFederationStrategy + lock context', } // Decrypting without the identity claim cannot reproduce the key tag. + // + // `decryptModel` REPORTS failure as a `Result` rather than throwing, so the + // previous `try/catch` here ran zero assertions on the happy path and would + // also have passed had the decryption wrongly SUCCEEDED. Accept denial via + // either channel, but require that it is denied. + let denied = false + let message = '' try { - await protectClient.decryptModel(encryptedModel.data) + const result = await protectClient.decryptModel(encryptedModel.data) + if (result.failure) { + denied = true + message = result.failure.message + } } catch (error) { - const e = error as Error - expect(e.message.startsWith('Failed to retrieve key')).toEqual(true) + denied = true + message = (error as Error).message } + + expect(denied).toBe(true) + expect(message).toMatch(/^Failed to retrieve key/) }, 30000) it('should bulk encrypt and decrypt models bound to the user identity', async () => { diff --git a/packages/stack/__tests__/match-bloom-live.test.ts b/packages/stack/__tests__/match-bloom-live.test.ts new file mode 100644 index 000000000..c9c5b8a74 --- /dev/null +++ b/packages/stack/__tests__/match-bloom-live.test.ts @@ -0,0 +1,140 @@ +import 'dotenv/config' +import { encrypt, encryptQuery, newClient } from '@cipherstash/protect-ffi' +import { beforeAll, describe, expect, it } from 'vitest' +import { defaultMatchOpts } from '@/schema/match-defaults' + +/** + * Pins what protect-ffi's match index ACTUALLY emits, against real ffi. + * + * This suite exists because a claim about ffi's bloom filter — that + * `include_original: true` appends a whole-value token, so a substring `contains` + * can never match — was asserted in a code comment, propagated into the docs and + * the changeset, and then "confirmed" by `supabase-v3-pgrest-live.test.ts`, whose + * credential-free fake built the extra token itself. Nothing tied that fake to + * ffi, so the fiction round-tripped. It cost a bug report (CIP-3483) and a + * limitation callout in the published docs. + * + * The invariant can only be observed where the bloom is actually built, so these + * tests call ffi directly rather than going through a stack builder. They need + * CipherStash credentials but no database. + */ +const TABLE = 'match_bloom_probe' +const COLUMN = 'col' + +/** A match column, tokenized exactly as the shared defaults specify. */ +const encryptConfigWith = (includeOriginal: boolean) => ({ + v: 1, + tables: { + [TABLE]: { + [COLUMN]: { + cast_as: 'text' as const, + indexes: { + match: { ...defaultMatchOpts(), include_original: includeOriginal }, + }, + }, + }, + }, +}) + +type Client = Awaited> + +describe('protect-ffi match bloom', () => { + let withOriginal: Client + let withoutOriginal: Client + + beforeAll(async () => { + withOriginal = await newClient({ + encryptConfig: encryptConfigWith(true), + eqlVersion: 3, + }) + withoutOriginal = await newClient({ + encryptConfig: encryptConfigWith(false), + eqlVersion: 3, + }) + }) + + const bloomOf = async (client: Client, plaintext: string) => { + const payload = await encrypt(client, { + plaintext, + table: TABLE, + column: COLUMN, + }) + return (payload as { bf?: number[] }).bf ?? [] + } + + // The bloom of a QUERY term, produced the way a `contains` query actually + // produces its needle — `encryptQuery` with the `match` index type, not + // `encrypt`. This is the operand `eql_v3.contains` binds on the right of `@>`, + // so a subset test against a stored `bloomOf` value is the real query path, + // not a same-function artefact comparing `encrypt` to itself. + const queryBloomOf = async (client: Client, plaintext: string) => { + const term = await encryptQuery(client, { + plaintext, + table: TABLE, + column: COLUMN, + indexType: 'match', + }) + return (term as { bf?: number[] }).bf ?? [] + } + + /** + * ffi emits the bloom's bits in a nondeterministic ORDER — two encrypts of the + * same plaintext on the same client differ in sequence while carrying the same + * bits. Only the bit SET is meaningful (`@>` is `smallint[]` containment), so + * every comparison here sorts first. + */ + const sorted = (bits: number[]) => [...bits].sort((a, b) => a - b) + + // The claim, killed at its source. `include_original` is accepted by the + // config and ignored: the bloom is the tokenizer's trigrams, nothing more. + // If a future ffi starts honouring the flag, THIS fails — and the v3 domains + // already emit `false` (see `eql/v3/columns.ts`), so `contains` keeps working. + it.each([ + 'Ada Lovelace', + 'ada@example.com', + ])('emits the same bloom for %j whether include_original is on or off', async (plaintext) => { + const on = await bloomOf(withOriginal, plaintext) + const off = await bloomOf(withoutOriginal, plaintext) + + expect(sorted(on)).toEqual(sorted(off)) + // A trigram-only bloom, not one carrying an extra whole-value token: 6 + // bits (k) per DISTINCT trigram, so never more than 6 × the trigram count. + expect(on.length).toBeLessThanOrEqual(6 * (plaintext.length - 2)) + expect(on.length).toBeGreaterThan(0) + }) + + // The corollary, and the reason `matchNeedleError` must reject short needles + // instead of trusting `include_original` to make them matchable: below + // `token_length` there are no trigrams, so the bloom is EMPTY under either + // setting — and `stored_bf @> '{}'` is true for every row. + it.each([ + ['with include_original', true], + ['without include_original', false], + ] as const)('blooms a sub-trigram value to nothing, %s', async (_label, on) => { + const bloom = await bloomOf(on ? withOriginal : withoutOriginal, 'ad') + + expect(bloom).toEqual([]) + }) + + // The query needle's bloom is a subset of the STORED value's bloom — which is + // exactly what `eql_v3.contains` (`match_term(stored) @> query_term(needle)`) + // tests. The haystack is a stored `encrypt` value; each needle is an + // `encryptQuery` `match` term, the real operand the containment query binds — + // so this exercises the query path, not `encrypt` compared to itself. This is + // the substring case CIP-3483 reported as broken, proven at the bloom layer; + // `drizzle-v3/operators-live-pg.test.ts` proves the same thing through SQL. + it('blooms a substring query needle into a subset of the stored value bloom', async () => { + const haystack = new Set(await bloomOf(withOriginal, 'ada@example.com')) + + for (const needle of ['ada', 'example', 'ada@example.com']) { + const bits = await queryBloomOf(withOriginal, needle) + expect(bits.length).toBeGreaterThan(0) + expect(bits.filter((bit) => !haystack.has(bit))).toEqual([]) + } + + // A needle sharing no trigram must NOT be a subset, or the assertion above + // would hold for anything. + const absent = await queryBloomOf(withOriginal, 'zzz') + expect(absent.some((bit) => !haystack.has(bit))).toBe(true) + }) +}) diff --git a/packages/stack/__tests__/match-needle-guard.test.ts b/packages/stack/__tests__/match-needle-guard.test.ts new file mode 100644 index 000000000..d5ca8048c --- /dev/null +++ b/packages/stack/__tests__/match-needle-guard.test.ts @@ -0,0 +1,93 @@ +import { describe, expect, it } from 'vitest' +import type { MatchIndexOpts } from '@/schema' +import { matchNeedleError, matchNeedleMinLength } from '@/schema/match-defaults' + +// The floor a free-text needle must clear before it yields any ngram. A needle +// below it tokenizes to nothing, so its bloom filter is EMPTY — and +// `stored_bf @> '{}'` is true for every row. Such a query is unanswerable, not +// merely unmatched, so the guard must reject it rather than silently return the +// whole table. +const ngram: MatchIndexOpts = { tokenizer: { kind: 'ngram', token_length: 3 } } + +describe('matchNeedleMinLength', () => { + it('is the ngram tokenizer token_length', () => { + expect(matchNeedleMinLength(ngram)).toBe(3) + expect( + matchNeedleMinLength({ tokenizer: { kind: 'ngram', token_length: 4 } }), + ).toBe(4) + }) + + it('defaults an absent tokenizer to the schema default rather than skipping the floor', () => { + expect(matchNeedleMinLength({})).toBe(3) + }) +}) + +describe('matchNeedleError', () => { + it('accepts a needle at or above the floor', () => { + expect(matchNeedleError('joh', ngram)).toBeUndefined() + expect(matchNeedleError('lovelace', ngram)).toBeUndefined() + }) + + it('rejects a needle below the floor, naming the floor and the term', () => { + expect(matchNeedleError('ad', ngram)).toMatch(/at least 3 characters/) + expect(matchNeedleError('ad', ngram)).toMatch(/"ad"/) + }) + + // The tokenizer counts Unicode CODEPOINTS. `'👍👍'` is 2 codepoints but 4 + // UTF-16 code units, so a `needle.length` check waves it through — and it + // then matches every row. Measured live: 3/3 rows returned. + it('rejects an astral-plane needle below the floor in CODEPOINTS, not UTF-16 units', () => { + expect('👍👍'.length).toBe(4) // pins why a naive length check passes it + expect([...'👍👍'].length).toBe(2) + + expect(matchNeedleError('👍👍', ngram)).toMatch(/at least 3 characters/) + }) + + it('reports the codepoint count, not the UTF-16 length, in the message', () => { + expect(matchNeedleError('👍👍', ngram)).toMatch(/has 2\b/) + }) + + it('accepts an astral-plane needle that reaches the floor in codepoints', () => { + expect(matchNeedleError('👍👍👍', ngram)).toBeUndefined() + }) + + // Combining acute accents. NFD 'e\u0301e\u0301' is 4 codepoints but only 2 + // grapheme clusters, and (measured live) builds a NON-empty filter — so the + // unit is codepoints, not graphemes. A grapheme floor would wrongly reject it. + // + // Built from explicit escapes: the PRECOMPOSED NFC form is a different string + // of only 2 codepoints, which the guard correctly rejects. A bare literal here + // would test whichever form the file happened to be normalised to on disk. + const NFD_EE = 'e\u0301e\u0301' + const NFC_EE = '\u00e9\u00e9' + + it('accepts a combining-accent needle that is 4 codepoints but only 2 graphemes', () => { + expect([...NFD_EE].length).toBe(4) + expect(matchNeedleError(NFD_EE, ngram)).toBeUndefined() + }) + + it('rejects the precomposed NFC form, which really is 2 codepoints', () => { + expect([...NFC_EE].length).toBe(2) + expect(matchNeedleError(NFC_EE, ngram)).toMatch(/at least 3 characters/) + }) + + it('rejects the empty needle whatever the tokenizer', () => { + expect(matchNeedleError('', ngram)).toBeTypeOf('string') + // A `standard` tokenizer imposes no ngram floor, but the empty string still + // yields zero tokens and so still matches every row. + expect( + matchNeedleError('', { tokenizer: { kind: 'standard' } }), + ).toBeTypeOf('string') + }) + + it('imposes no floor on a non-empty needle under a standard tokenizer', () => { + expect( + matchNeedleError('a', { tokenizer: { kind: 'standard' } }), + ).toBeUndefined() + }) + + it('ignores non-string operands, leaving them to the encryption layer', () => { + expect(matchNeedleError(42, ngram)).toBeUndefined() + expect(matchNeedleError(null, ngram)).toBeUndefined() + }) +}) diff --git a/packages/stack/__tests__/schema-builders.test.ts b/packages/stack/__tests__/schema-builders.test.ts index 6571dd00a..a2bdc810b 100644 --- a/packages/stack/__tests__/schema-builders.test.ts +++ b/packages/stack/__tests__/schema-builders.test.ts @@ -117,6 +117,7 @@ describe('schema builders', () => { expect(built.indexes.ste_vec).toEqual({ prefix: 'enabled', array_index_mode: 'all', + mode: 'standard', }) }) @@ -226,6 +227,7 @@ describe('schema builders', () => { expect(built.columns.metadata.indexes.ste_vec).toEqual({ prefix: 'documents/metadata', array_index_mode: 'all', + mode: 'standard', }) }) @@ -318,6 +320,7 @@ describe('schema builders', () => { expect(config.tables.documents.metadata.indexes.ste_vec).toEqual({ prefix: 'documents/metadata', array_index_mode: 'all', + mode: 'standard', }) }) }) diff --git a/packages/stack/__tests__/schema-v3.test-d.ts b/packages/stack/__tests__/schema-v3.test-d.ts index b39bf3520..cd2911026 100644 --- a/packages/stack/__tests__/schema-v3.test-d.ts +++ b/packages/stack/__tests__/schema-v3.test-d.ts @@ -1,6 +1,7 @@ import { describe, expectTypeOf, it } from 'vitest' import { Encryption, type EncryptionClient } from '@/encryption' import type { + EncryptedBigintColumn, EncryptedTextSearchColumn, InferEncrypted, InferPlaintext, @@ -21,6 +22,11 @@ describe('eql_v3 schema type inference', () => { expectTypeOf(col).toEqualTypeOf() }) + it('types.Bigint returns an EncryptedBigintColumn (native bigint round-trip on protect-ffi 0.28)', () => { + const col = types.Bigint('large') + expectTypeOf(col).toEqualTypeOf() + }) + it('encryptedTable exposes column builders as typed properties', () => { const users = encryptedTable('users', { email: types.TextSearch('email'), @@ -60,6 +66,7 @@ describe('eql_v3 schema type inference', () => { active: types.Boolean('active'), createdAt: types.Timestamp('created_at'), score: types.Double('score'), + balance: types.BigintOrd('balance'), }) type Plaintext = InferPlaintext @@ -70,6 +77,7 @@ describe('eql_v3 schema type inference', () => { active: boolean createdAt: Date score: number + balance: bigint }>() }) @@ -102,6 +110,20 @@ describe('eql_v3 client integration (type-level acceptance)', () => { }) }) + it('encrypt and encryptQuery accept bigint plaintext (native round-tripping landed in protect-ffi 0.28)', () => { + const client = {} as EncryptionClient + + expectTypeOf(client.encrypt).toBeCallableWith(1n, { + table: v3users, + column: v3users.email, + }) + + expectTypeOf(client.encryptQuery).toBeCallableWith(1n, { + table: v3users, + column: v3users.email, + }) + }) + it('encryptQuery accepts a v3 table + column', () => { const client = {} as EncryptionClient expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { diff --git a/packages/stack/__tests__/schema-v3.test.ts b/packages/stack/__tests__/schema-v3.test.ts index 8941a163c..17c66b170 100644 --- a/packages/stack/__tests__/schema-v3.test.ts +++ b/packages/stack/__tests__/schema-v3.test.ts @@ -11,76 +11,59 @@ import { encryptConfigSchema, encryptedColumn } from '@/schema' import { type DomainSpec, typedEntries, V3_MATRIX } from './v3-matrix/catalog' describe('eql_v3 text_search column', () => { - it('LOAD-BEARING: default build() deep-equals the v2 equality+order+match column', () => { + it('LOAD-BEARING: default build() matches the v2 equality+order+match column modulo the ordering index and include_original', () => { + // eql-3.0.0 pins text_search's ordering to CLLW-OPE (`ope`/`op` term); the + // v2 fluent builder keeps block-ORE (`ore`/`ob`) — its wire format must not + // change. Everything else (unique, match, cast_as) stays byte-identical. const v3 = types.TextSearch('email').build() const v2 = encryptedColumn('email') .equality() .orderAndRange() .freeTextSearch() .build() + expect(v3.indexes.ope).toEqual({}) + expect(v3.indexes.ore).toBeUndefined() + expect(v2.indexes.ore).toEqual({}) + expect(v2.indexes.ope).toBeUndefined() + + // The second deliberate divergence. protect-ffi ignores `include_original` + // (`match-bloom-live.test.ts` pins that against real ffi), so v3 emits the + // value a substring-search domain wants while v2 holds its historical + // `true` — no v2 wire movement. Asserted on BOTH sides, then excluded from + // the byte-identity check below, so neither can drift unnoticed. + expect(v3.indexes.match?.include_original).toBe(false) + expect(v2.indexes.match?.include_original).toBe(true) + + const { ope: _v3Ord, match: v3Match, ...v3Rest } = v3.indexes + const { ore: _v2Ord, match: v2Match, ...v2Rest } = v2.indexes + const withoutIncludeOriginal = (match: typeof v3Match) => { + if (!match) return match + const { include_original: _drop, ...rest } = match + return rest + } // toStrictEqual: byte-identical, no extra/undefined keys on either side. - expect(v3).toStrictEqual(v2) + expect({ + ...v3, + indexes: { ...v3Rest, match: withoutIncludeOriginal(v3Match) }, + }).toStrictEqual({ + ...v2, + indexes: { ...v2Rest, match: withoutIncludeOriginal(v2Match) }, + }) }) - it('.freeTextSearch(opts) overrides each provided key and keeps the rest as defaults', () => { - const built = types - .TextSearch('email') - .freeTextSearch({ - tokenizer: { kind: 'ngram', token_length: 4 }, - k: 8, - m: 4096, - include_original: false, - }) - .build() + it('default build() emits the unique, ope, and match indexes', () => { + const built = types.TextSearch('email').build() + expect(built.indexes.unique).toEqual({ token_filters: [] }) + expect(built.indexes.ope).toEqual({}) expect(built.indexes.match).toEqual({ - tokenizer: { kind: 'ngram', token_length: 4 }, - // omitted -> default downcase filter retained + tokenizer: { kind: 'ngram', token_length: 3 }, token_filters: [{ kind: 'downcase' }], - k: 8, - m: 4096, + k: 6, + m: 2048, include_original: false, }) }) - it('.freeTextSearch({ token_filters: [] }) overrides the downcase default with an empty array', () => { - // LOAD-BEARING: `[] ?? default` evaluates to `[]` (an empty array is not - // nullish), so an explicit empty array must OVERRIDE the downcase default, - // not fall back to it. Mirrors v2 (schema-builders.test.ts). - const built = types - .TextSearch('email') - .freeTextSearch({ token_filters: [] }) - .build() - expect(built.indexes.match.token_filters).toEqual([]) - }) - - it('repeated .freeTextSearch() calls are last-call-wins-fully (each re-merges against defaults, not prior state)', () => { - // Each call re-merges against a fresh defaultMatchOpts(), not the - // accumulated matchOpts — so the second call resets k back to its default - // of 6. This is intentional: it mirrors v2 exactly. Pinned here so a future - // "merge against current state" change can't silently slip in. - const built = types - .TextSearch('email') - .freeTextSearch({ k: 8 }) - .freeTextSearch({ m: 4096 }) - .build() - expect(built.indexes.match.k).toBe(6) - expect(built.indexes.match.m).toBe(4096) - }) - - it('.freeTextSearch() with no argument is a no-op: build() equals the default build()', () => { - // Pins the opts === undefined branch: every `opts?.x ?? default` falls - // through, so a bare call must emit exactly the default match block. - expect(types.TextSearch('email').freeTextSearch().build()).toStrictEqual( - types.TextSearch('email').build(), - ) - }) - - it('.freeTextSearch() is tuning-only: unique and ore indexes stay present', () => { - const built = types.TextSearch('email').freeTextSearch({ k: 8 }).build() - expect(built.indexes.unique).toEqual({ token_filters: [] }) - expect(built.indexes.ore).toEqual({}) - }) - it('built columns share no mutable state: mutating one build() output does not affect another', () => { // Guards against the shared-defaults aliasing bug: defaults come from a // per-instance factory and build() deep-clones the match block. @@ -104,29 +87,6 @@ describe('eql_v3 text_search column', () => { expect(c.indexes.match.k).toBe(6) expect(c.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) }) - - it('clones caller opts on freeTextSearch(): mutating them before build() does not leak', () => { - // build() deep-clones at build time, but if freeTextSearch stored the - // caller's nested tokenizer / token_filters by reference, a caller mutating - // their own opts object between freeTextSearch(opts) and build() would leak - // the mutation into the emitted config. freeTextSearch must clone on write. - const opts = { - tokenizer: { kind: 'ngram' as const, token_length: 3 }, - token_filters: [{ kind: 'downcase' as const }], - } - const col = types.TextSearch('email').freeTextSearch(opts) - - // Mutate the caller's own opts AFTER freeTextSearch but BEFORE build(). - opts.tokenizer.token_length = 999 - opts.token_filters.push({ kind: 'downcase' as const }) - - const built = col.build() - expect(built.indexes.match.tokenizer).toEqual({ - kind: 'ngram', - token_length: 3, - }) - expect(built.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) - }) }) describe('eql_v3 text_match column', () => { @@ -156,6 +116,47 @@ describe('eql_v3 text_match column', () => { }) }) +describe('eql_v3 concrete type names', () => { + it('preserves public factory names while exposing concrete Postgres domain names', () => { + expect(types.Integer('n').getEqlType()).toBe('public.eql_v3_integer') + expect(types.IntegerEq('n').getEqlType()).toBe('public.eql_v3_integer_eq') + expect(types.IntegerOrdOre('n').getEqlType()).toBe( + 'public.eql_v3_integer_ord_ore', + ) + expect(types.IntegerOrd('n').getEqlType()).toBe('public.eql_v3_integer_ord') + + expect(types.Smallint('n').getEqlType()).toBe('public.eql_v3_smallint') + expect(types.SmallintEq('n').getEqlType()).toBe('public.eql_v3_smallint_eq') + expect(types.SmallintOrdOre('n').getEqlType()).toBe( + 'public.eql_v3_smallint_ord_ore', + ) + expect(types.SmallintOrd('n').getEqlType()).toBe( + 'public.eql_v3_smallint_ord', + ) + + expect(types.Bigint('n').getEqlType()).toBe('public.eql_v3_bigint') + expect(types.BigintEq('n').getEqlType()).toBe('public.eql_v3_bigint_eq') + expect(types.BigintOrdOre('n').getEqlType()).toBe( + 'public.eql_v3_bigint_ord_ore', + ) + expect(types.BigintOrd('n').getEqlType()).toBe('public.eql_v3_bigint_ord') + + expect(types.Boolean('b').getEqlType()).toBe('public.eql_v3_boolean') + expect(types.Real('n').getEqlType()).toBe('public.eql_v3_real') + expect(types.RealEq('n').getEqlType()).toBe('public.eql_v3_real_eq') + expect(types.RealOrdOre('n').getEqlType()).toBe( + 'public.eql_v3_real_ord_ore', + ) + expect(types.RealOrd('n').getEqlType()).toBe('public.eql_v3_real_ord') + expect(types.Double('n').getEqlType()).toBe('public.eql_v3_double') + expect(types.DoubleEq('n').getEqlType()).toBe('public.eql_v3_double_eq') + expect(types.DoubleOrdOre('n').getEqlType()).toBe( + 'public.eql_v3_double_ord_ore', + ) + expect(types.DoubleOrd('n').getEqlType()).toBe('public.eql_v3_double_ord') + }) +}) + describe('eql_v3 encryptedTable', () => { it('creates a table exposing column builders as properties', () => { const users = encryptedTable('users', { @@ -198,18 +199,22 @@ describe('eql_v3 encryptedTable', () => { }) const built = users.build() expect(built.tableName).toBe('users') - expect(built.columns).toStrictEqual({ + // Spread to a plain object: `columns` is null-prototype (a DB column named + // `__proto__` must land as an own key), and `toStrictEqual` compares + // prototypes. The contract under test is the column configs, not the + // prototype — which `supabase-schema-builder.test.ts` pins directly. + expect({ ...built.columns }).toStrictEqual({ email: { cast_as: 'string', indexes: { unique: { token_filters: [] }, - ore: {}, + ope: {}, match: { tokenizer: { kind: 'ngram', token_length: 3 }, token_filters: [{ kind: 'downcase' }], k: 6, m: 2048, - include_original: true, + include_original: false, }, }, }, @@ -334,16 +339,17 @@ const SCALAR_QUERY_TYPES = [ // The ground-truth for whether `resolveIndexType` accepts a (domain, queryType) // pair: does the domain carry the index that query resolves to? Derived from the -// catalog's `indexes` data, AMENDED for the equality-via-ORE rule — an -// order-capable column answers equality via its `ore` index, not `unique`. This -// mirrors `resolveIndexType`'s real logic, so it needs no live FFI. +// catalog's `indexes` data, AMENDED for the equality-via-ordering rule — an +// order-capable column answers equality via its ordering index (`ope` on `_ord` +// domains, `ore` on `_ord_ore`), not `unique`. This mirrors +// `resolveIndexType`'s real logic, so it needs no live FFI. function queryTypeAllowed( indexes: DomainSpec['indexes'], queryType: (typeof SCALAR_QUERY_TYPES)[number], ): boolean { const idx = indexes ?? {} - if (queryType === 'equality') return Boolean(idx.unique || idx.ore) - if (queryType === 'orderAndRange') return Boolean(idx.ore) + if (queryType === 'equality') return Boolean(idx.unique || idx.ore || idx.ope) + if (queryType === 'orderAndRange') return Boolean(idx.ore || idx.ope) return Boolean(idx.match) // freeTextSearch } @@ -394,20 +400,24 @@ describe('eql_v3 catalog-driven query capability sweep', () => { }) }) -describe('eql_v3 equality via ORE on order-capable columns (regression)', () => { - // The capability contract documents equality as answerable "via `ob`", so a - // numeric/date order-capable column (which has NO `hm`) resolves equality to - // its `ore` index (same term as orderAndRange, distinguished by the SQL `=` - // operator) instead of throwing on the absent `unique` index. (Text order - // domains DO carry `hm` and resolve equality to `unique` instead — see the - // text-order regression below.) +describe('eql_v3 equality via the ordering index on order-capable columns (regression)', () => { + // The capability contract documents equality as answerable via the ordering + // term, so a numeric/date order-capable column (which has NO `hm`) resolves + // equality to its ordering index (same term as orderAndRange, distinguished + // by the SQL `=` operator) instead of throwing on the absent `unique` index. + // `_ord` domains are OPE-backed (eql-3.0.0), `_ord_ore` keep block-ORE. + // (Text order domains DO carry `hm` and resolve equality to `unique` + // instead — see the text-order regression below.) + // Keep these labels aligned with the checked-in EQL build; a mismatch here + // means the stack package is out of sync with the underlying domain surface. it.each([ - ['integer_ord', types.IntegerOrd], - ['date_ord', types.DateOrd], - ['numeric_ord', types.NumericOrd], - ] as const)('%s resolves equality to the ore index', (_name, builder) => { + ['IntegerOrd', types.IntegerOrd, 'ope'], + ['date_ord', types.DateOrd, 'ope'], + ['numeric_ord', types.NumericOrd, 'ope'], + ['IntegerOrdOre', types.IntegerOrdOre, 'ore'], + ] as const)('%s resolves equality to its ordering index (%s)', (_name, builder, ordering) => { expect(resolveIndexType(builder('value'), 'equality')).toEqual({ - indexType: 'ore', + indexType: ordering, }) }) @@ -422,29 +432,30 @@ describe('eql_v3 equality via ORE on order-capable columns (regression)', () => }) describe('eql_v3 text order domains carry the hm (unique) index (regression)', () => { - // The `eql_v3.text_ord` and `eql_v3.text_ord_ore` SQL domains require BOTH + // The `public.eql_v3_text_ord` and `public.eql_v3_text_ord_ore` SQL domains require BOTH // `hm` (HMAC) and `ob` (ORE) in the stored ciphertext: text equality is // HMAC-based (their `eql_v3.eq_term` extracts `hm`), unlike numeric/date order // domains which answer equality via `ob` and need only ORE. So text order // columns must emit `unique` (hm) IN ADDITION to `ore` (ob), or a real INSERT - // fails with `value for domain eql_v3.text_ord_ore violates check constraint`. + // fails with `value for domain public.eql_v3_text_ord_ore violates check constraint`. it.each([ - ['text_ord_ore', types.TextOrdOre], - ['text_ord', types.TextOrd], - ] as const)('%s emits both unique (hm) and ore (ob)', (_name, builder) => { - expect(builder('c').build().indexes).toStrictEqual({ - unique: { token_filters: [] }, - ore: {}, - }) + [ + 'text_ord_ore', + types.TextOrdOre, + { unique: { token_filters: [] }, ore: {} }, + ], + ['text_ord', types.TextOrd, { unique: { token_filters: [] }, ope: {} }], + ] as const)('%s emits both unique (hm) and its ordering index', (_name, builder, expected) => { + expect(builder('c').build().indexes).toStrictEqual(expected) }) it.each([ - ['integer_ord_ore', types.IntegerOrdOre], - ['integer_ord', types.IntegerOrd], - ['date_ord_ore', types.DateOrdOre], - ['numeric_ord', types.NumericOrd], - ] as const)('%s (numeric/date order) emits ore only — no unique', (_name, builder) => { - expect(builder('c').build().indexes).toStrictEqual({ ore: {} }) + ['IntegerOrdOre', types.IntegerOrdOre, { ore: {} }], + ['IntegerOrd', types.IntegerOrd, { ope: {} }], + ['date_ord_ore', types.DateOrdOre, { ore: {} }], + ['numeric_ord', types.NumericOrd, { ope: {} }], + ] as const)('%s (numeric/date order) emits its ordering index only — no unique', (_name, builder, expected) => { + expect(builder('c').build().indexes).toStrictEqual(expected) }) // With `unique` present, text order equality resolves to the hm index (not @@ -458,3 +469,22 @@ describe('eql_v3 text order domains carry the hm (unique) index (regression)', ( }) }) }) + +describe('eql_v3 timestamp domains emit cast_as "timestamp" (time-of-day preserved)', () => { + // The FFI has a distinct `timestamp` cast (full date+time) separate from + // `date` (calendar-date only). Every timestamp domain must emit + // `cast_as: 'timestamp'` so the native layer keeps the time-of-day instead of + // truncating to midnight (see schema-v3-client occurredAt round-trip). + it.each([ + ['timestamp', types.Timestamp], + ['timestamp_eq', types.TimestampEq], + ['timestamp_ord_ore', types.TimestampOrdOre], + ['timestamp_ord', types.TimestampOrd], + ] as const)('%s emits cast_as "timestamp"', (_name, builder) => { + expect(builder('c').build().cast_as).toBe('timestamp') + }) + + it('the plain date domain still emits cast_as "date"', () => { + expect(types.Date('c').build().cast_as).toBe('date') + }) +}) diff --git a/packages/stack/__tests__/supabase-v3-builder.test.ts b/packages/stack/__tests__/supabase-v3-builder.test.ts deleted file mode 100644 index 5fa9d8d02..000000000 --- a/packages/stack/__tests__/supabase-v3-builder.test.ts +++ /dev/null @@ -1,563 +0,0 @@ -import { describe, expect, it } from 'vitest' -import type { EncryptionClient } from '@/encryption' -import { encryptedTable, types } from '@/eql/v3' -import { encryptedColumn, encryptedTable as encryptedTableV2 } from '@/schema' -import { encryptedSupabase, encryptedSupabaseV3 } from '@/supabase' - -// --------------------------------------------------------------------------- -// Mocks -// -// The builders only touch a narrow slice of the encryption client and the -// supabase client, so both are simulated: the encryption mock produces -// deterministic fake envelopes (carrying the plaintext in `pt` so the fake -// decrypt can undo them), and the supabase mock records every builder call. -// This pins the WIRE ENCODING each dialect produces — the part of the adapter -// that CI can verify without a live Supabase project. -// --------------------------------------------------------------------------- - -type FakeEnvelope = { - v: 3 - i: { t: string; c: string } - c: string - hm: string - pt: unknown -} - -function fakeEnvelope(value: unknown, column: string): FakeEnvelope { - const pt = value instanceof Date ? value.toISOString() : value - return { - v: 3, - i: { t: 'tbl', c: column }, - c: `ct:${String(pt)}`, - hm: `hm:${String(pt)}`, - pt, - } -} - -function isFakeEnvelope(value: unknown): value is FakeEnvelope { - return ( - typeof value === 'object' && - value !== null && - 'pt' in value && - 'c' in value && - 'hm' in value - ) -} - -/** A chainable operation resolving to `{ data }`, like the real ones. */ -function operation(data: T) { - const op = { - withLockContext: () => op, - audit: () => op, - then: ( - onfulfilled?: ((value: { data: T }) => unknown) | null, - onrejected?: ((reason: unknown) => unknown) | null, - ) => Promise.resolve({ data }).then(onfulfilled, onrejected), - } - return op -} - -type SchemaLike = { - build(): { columns: Record } - buildColumnKeyMap?(): Record -} - -function createMockEncryptionClient() { - const encryptedProps = (table: SchemaLike): string[] => - table.buildColumnKeyMap - ? Object.keys(table.buildColumnKeyMap()) - : Object.keys(table.build().columns) - - const client = { - encrypt: (value: unknown, opts: { column: { getName(): string } }) => - operation(fakeEnvelope(value, opts.column.getName())), - - // v2 filter path: batch query terms as composite literals - encryptQuery: (terms: Array<{ value: unknown }>) => - operation(terms.map((t) => `("${String(t.value)}")`)), - - encryptModel: (model: Record, table: SchemaLike) => { - const props = encryptedProps(table) - const out: Record = { ...model } - for (const prop of props) { - if (out[prop] != null) out[prop] = fakeEnvelope(out[prop], prop) - } - return operation(out) - }, - - bulkEncryptModels: ( - models: Record[], - table: SchemaLike, - ) => { - const props = encryptedProps(table) - return operation( - models.map((model) => { - const out: Record = { ...model } - for (const prop of props) { - if (out[prop] != null) out[prop] = fakeEnvelope(out[prop], prop) - } - return out - }), - ) - }, - - decryptModel: (model: Record) => { - const out: Record = {} - for (const [key, value] of Object.entries(model)) { - out[key] = isFakeEnvelope(value) ? value.pt : value - } - return operation(out) - }, - - bulkDecryptModels: (models: Record[]) => - operation( - models.map((model) => { - const out: Record = {} - for (const [key, value] of Object.entries(model)) { - out[key] = isFakeEnvelope(value) ? value.pt : value - } - return out - }), - ), - } - - return client as unknown as EncryptionClient -} - -type RecordedCall = { method: string; args: unknown[] } - -function createMockSupabase(resultData: unknown = []) { - const calls: RecordedCall[] = [] - // biome-ignore lint/suspicious/noExplicitAny: test double for the supabase query builder - const qb: any = {} - const methods = [ - 'select', - 'insert', - 'update', - 'upsert', - 'delete', - 'eq', - 'neq', - 'gt', - 'gte', - 'lt', - 'lte', - 'like', - 'ilike', - 'is', - 'in', - 'filter', - 'not', - 'or', - 'match', - 'order', - 'limit', - 'range', - 'single', - 'maybeSingle', - 'csv', - 'abortSignal', - 'throwOnError', - ] - for (const method of methods) { - qb[method] = (...args: unknown[]) => { - calls.push({ method, args }) - return qb - } - } - qb.then = ( - onfulfilled?: ((value: unknown) => unknown) | null, - onrejected?: ((reason: unknown) => unknown) | null, - ) => - Promise.resolve({ - data: resultData, - error: null, - count: null, - status: 200, - statusText: 'OK', - }).then(onfulfilled, onrejected) - - const client = { from: (_table: string) => qb } - const callsFor = (method: string) => calls.filter((c) => c.method === method) - - return { client, calls, callsFor } -} - -// --------------------------------------------------------------------------- -// Schemas -// --------------------------------------------------------------------------- - -const users = encryptedTable('users', { - email: types.TextSearch('email'), - nickname: types.TextEq('nickname'), - amount: types.IntegerOrd('amount'), - createdAt: types.TimestampOrd('created_at'), - active: types.Boolean('active'), -}) - -const usersV2 = encryptedTableV2('users', { - email: encryptedColumn('email').freeTextSearch().equality(), - age: encryptedColumn('age').dataType('number').equality().orderAndRange(), -}) - -// Explicit row type: the default `Row` is exactly the table's plaintext shape, -// so passthrough columns (id, note) need an explicit `Row` to be filterable / -// insertable at the type level. -type UserRow = { - id: number - email: string - nickname: string - amount: number - createdAt: Date - active: boolean - note: string -} - -function v3Instance(resultData: unknown = []) { - const supabase = createMockSupabase(resultData) - const es = encryptedSupabaseV3({ - encryptionClient: createMockEncryptionClient(), - supabaseClient: supabase.client, - }) - const from = () => es.from('users', users) - return { es, from, supabase } -} - -// --------------------------------------------------------------------------- -// v3 dialect -// --------------------------------------------------------------------------- - -describe('encryptedSupabaseV3 wire encoding', () => { - it('inserts the raw encrypted payload keyed by DB column name (no composite wrap)', async () => { - const { from, supabase } = v3Instance() - - const createdAt = new Date('2026-01-02T03:04:05.000Z') - await from().insert({ email: 'a@b.com', createdAt, note: 'plain' }) - - const [insert] = supabase.callsFor('insert') - expect(insert).toBeDefined() - const body = insert.args[0] as Record - - // Property createdAt lands in DB column created_at - expect(Object.keys(body).sort()).toEqual(['created_at', 'email', 'note']) - // Raw envelope — NOT v2's `{ data: ... }` composite wrap - expect(isFakeEnvelope(body.email)).toBe(true) - expect((body.email as Record).data).toBeUndefined() - expect(isFakeEnvelope(body.created_at)).toBe(true) - expect(body.note).toBe('plain') - }) - - it('bulk-inserts raw encrypted payloads keyed by DB column name', async () => { - const { from, supabase } = v3Instance() - - await from().insert([{ email: 'a@b.com' }, { email: 'b@c.com' }]) - - const [insert] = supabase.callsFor('insert') - const body = insert.args[0] as Record[] - expect(body).toHaveLength(2) - expect(isFakeEnvelope(body[0].email)).toBe(true) - expect(isFakeEnvelope(body[1].email)).toBe(true) - }) - - it('adds ::jsonb casts and aliases property names to DB names in select', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, email, createdAt') - - const [select] = supabase.callsFor('select') - expect(select.args[0]).toBe('id, email::jsonb, createdAt:created_at::jsonb') - }) - - it('encrypts equality operands as full-envelope jsonb text', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, email').eq('email', 'a@b.com') - - const eqCalls = supabase.callsFor('eq') - expect(eqCalls).toHaveLength(1) - const [column, term] = eqCalls[0].args - expect(column).toBe('email') - // The operand must be the FULL storage envelope (v/i/c + index terms) so - // it satisfies the eql_v3 domain CHECK when Postgres coerces it. - const parsed = JSON.parse(term as string) - expect(parsed.c).toBeDefined() - expect(parsed.i).toBeDefined() - expect(parsed.hm).toBeDefined() - }) - - it('passes non-encrypted filters through untouched', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, email').eq('id', 42) - - const eqCalls = supabase.callsFor('eq') - expect(eqCalls[0].args).toEqual(['id', 42]) - }) - - it('maps property names to DB names in range filters', async () => { - const { from, supabase } = v3Instance() - - const lowerBound = new Date('2026-01-01T00:00:00.000Z') - await from().select('id, createdAt').gte('createdAt', lowerBound) - - const [gte] = supabase.callsFor('gte') - expect(gte.args[0]).toBe('created_at') - expect(JSON.parse(gte.args[1] as string).c).toBeDefined() - }) - - it('emits encrypted like/ilike as PostgREST cs (bloom-filter containment)', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, email').like('email', 'a@b') - await from().select('id, email').ilike('email', 'a@b') - - const filterCalls = supabase.callsFor('filter') - expect(filterCalls).toHaveLength(2) - for (const call of filterCalls) { - expect(call.args[0]).toBe('email') - expect(call.args[1]).toBe('cs') - expect(JSON.parse(call.args[2] as string).c).toBeDefined() - } - // No bare like/ilike reached PostgREST for the encrypted column - expect(supabase.callsFor('like')).toHaveLength(0) - expect(supabase.callsFor('ilike')).toHaveLength(0) - }) - - it('keeps like on plain columns as like', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, email').like('note', '%x%') - - expect(supabase.callsFor('like')).toHaveLength(1) - expect(supabase.callsFor('filter')).toHaveLength(0) - }) - - it('maps not(like) on encrypted columns to not(cs)', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, email').not('email', 'like', 'a@b') - - const [not] = supabase.callsFor('not') - expect(not.args[0]).toBe('email') - expect(not.args[1]).toBe('cs') - }) - - it('encrypts each element of an in() filter', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, nickname').in('nickname', ['ada', 'grace']) - - const [inCall] = supabase.callsFor('in') - expect(inCall.args[0]).toBe('nickname') - const values = inCall.args[1] as string[] - expect(values).toHaveLength(2) - expect(JSON.parse(values[0]).pt).toBe('ada') - expect(JSON.parse(values[1]).pt).toBe('grace') - }) - - it('maps match() keys to DB names and encrypts values', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, nickname').match({ nickname: 'ada', id: 7 }) - - const [match] = supabase.callsFor('match') - const query = match.args[0] as Record - expect(JSON.parse(query.nickname as string).pt).toBe('ada') - expect(query.id).toBe(7) - }) - - it('rejects a query type the column does not support', async () => { - const { from } = v3Instance() - - // nickname is eql_v3.text_eq — equality only, no order/range - const { error, status } = await from() - .select('id, nickname') - .gte('nickname', 'a') - - expect(status).toBe(500) - expect(error?.message).toContain('does not support orderAndRange') - }) - - it('rejects filters on storage-only columns', async () => { - const { from } = v3Instance() - - // active is eql_v3.boolean — storage only - const { error, status } = await from() - .select('id') - // biome-ignore lint/suspicious/noExplicitAny: intentionally bypassing the type guard to prove the runtime guard - .eq('active' as any, true as any) - - expect(status).toBe(500) - expect(error?.message).toContain('does not support equality') - }) - - it('reconstructs Date values from cast_as on decrypted rows', async () => { - const rows = [ - { - id: 1, - email: fakeEnvelope('a@b.com', 'email'), - createdAt: fakeEnvelope( - new Date('2026-01-02T03:04:05.000Z'), - 'created_at', - ), - }, - ] - const { from } = v3Instance(rows) - - const { data, error } = await from().select('id, email, createdAt') - - expect(error).toBeNull() - expect(data).toHaveLength(1) - expect(data![0].email).toBe('a@b.com') - expect(data![0].createdAt).toBeInstanceOf(Date) - expect((data![0].createdAt as Date).toISOString()).toBe( - '2026-01-02T03:04:05.000Z', - ) - }) - - it('reconstructs Date values selected under a user-chosen PostgREST alias', async () => { - const rows = [ - { - id: 1, - ts: fakeEnvelope(new Date('2026-01-02T03:04:05.000Z'), 'created_at'), - }, - ] - const { from, supabase } = v3Instance(rows) - - const { data, error } = await from().select('id, ts:createdAt') - - // The alias resolves through the property to the DB column… - const [select] = supabase.callsFor('select') - expect(select.args[0]).toBe('id, ts:created_at::jsonb') - - // …and the aliased key still gets cast_as-driven Date reconstruction. - expect(error).toBeNull() - const row = data![0] as Record - expect(row.ts).toBeInstanceOf(Date) - expect((row.ts as Date).toISOString()).toBe('2026-01-02T03:04:05.000Z') - }) - - it('rebuilds structured or() conditions with DB names, cs remap, and encrypted operands', async () => { - const { from, supabase } = v3Instance() - - await from() - .select('id, email, createdAt') - .or([ - { column: 'email', op: 'ilike', value: 'a@b' }, - { column: 'createdAt', op: 'gte', value: new Date('2026-01-01') }, - { column: 'id', op: 'eq', value: 7 }, - ]) - - const [or] = supabase.callsFor('or') - const orString = or.args[0] as string - - // Encrypted ilike → cs, property → DB name, operand = quoted envelope - expect(orString).toContain('email.cs.') - expect(orString).not.toContain('email.ilike.') - expect(orString).toContain('created_at.gte.') - // Plain condition passes through untouched - expect(orString).toContain('id.eq.7') - // Encrypted operands are the full envelope (double-quoted by the - // or-string formatter because JSON contains reserved characters) - expect(orString).toContain('"{') - }) - - it('rebuilds string-form or() with encrypted conditions remapped', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, email').or('email.eq.a@b.com,id.eq.7') - - const [or] = supabase.callsFor('or') - const orString = or.args[0] as string - // The encrypted value is substituted; the plain condition survives as-is - expect(orString).toContain('email.eq."{') - expect(orString).toContain('id.eq.7') - }) - - it('passes a string-form or() through verbatim when no condition is encrypted', async () => { - const { from, supabase } = v3Instance() - - await from().select('id').or('id.eq.7,note.eq.x') - - const [or] = supabase.callsFor('or') - expect(or.args[0]).toBe('id.eq.7,note.eq.x') - }) - - it('rejects a null operand with a pointer to .is()', async () => { - const { from } = v3Instance() - - const { error, status } = await from() - .select('id, email') - // biome-ignore lint/suspicious/noExplicitAny: intentionally bypassing the type guard to prove the runtime guard - .eq('email', null as any) - - expect(status).toBe(500) - expect(error?.message).toContain('null filter value') - expect(error?.message).toContain(".is('email', null)") - }) - - it('still routes .is() null checks through untouched', async () => { - const { from, supabase } = v3Instance() - - await from().select('id, email').is('email', null) - - const [isCall] = supabase.callsFor('is') - expect(isCall.args).toEqual(['email', null]) - }) -}) - -// --------------------------------------------------------------------------- -// v2 regression — the dialect seams must leave the v2 wire encoding untouched -// --------------------------------------------------------------------------- - -describe('encryptedSupabase (v2) wire encoding is unchanged by the dialect seams', () => { - function v2Instance(resultData: unknown = []) { - const supabase = createMockSupabase(resultData) - const es = encryptedSupabase({ - encryptionClient: createMockEncryptionClient(), - supabaseClient: supabase.client, - }) - return { es, supabase } - } - - it('wraps encrypted mutation values in the { data } composite shape', async () => { - const { es, supabase } = v2Instance() - - await es.from('users', usersV2).insert({ email: 'a@b.com', note: 'x' }) - - const [insert] = supabase.callsFor('insert') - const body = insert.args[0] as Record - expect(body.email).toHaveProperty('data') - expect(isFakeEnvelope((body.email as Record).data)).toBe( - true, - ) - expect(body.note).toBe('x') - }) - - it('encodes filter terms as composite literals via encryptQuery', async () => { - const { es, supabase } = v2Instance() - - await es.from('users', usersV2).select('id, email').eq('email', 'a@b.com') - - const [eq] = supabase.callsFor('eq') - expect(eq.args).toEqual(['email', '("a@b.com")']) - }) - - it('keeps like on encrypted columns as like', async () => { - const { es, supabase } = v2Instance() - - await es.from('users', usersV2).select('id, email').like('email', 'a@b') - - expect(supabase.callsFor('like')).toHaveLength(1) - expect(supabase.callsFor('filter')).toHaveLength(0) - }) - - it('adds plain ::jsonb casts without aliasing', async () => { - const { es, supabase } = v2Instance() - - await es.from('users', usersV2).select('id, email, age') - - const [select] = supabase.callsFor('select') - expect(select.args[0]).toBe('id, email::jsonb, age::jsonb') - }) -}) diff --git a/packages/stack/__tests__/supabase-v3.test-d.ts b/packages/stack/__tests__/supabase-v3.test-d.ts deleted file mode 100644 index 2c709f082..000000000 --- a/packages/stack/__tests__/supabase-v3.test-d.ts +++ /dev/null @@ -1,135 +0,0 @@ -import { describe, expectTypeOf, it } from 'vitest' -import type { EncryptionClient } from '@/encryption' -import { encryptedTable, types } from '@/eql/v3' -import { encryptedColumn, encryptedTable as v2EncryptedTable } from '@/schema' -import { - type EncryptedQueryBuilder, - type EncryptedSupabaseResponse, - encryptedSupabase, - encryptedSupabaseV3, - type SupabaseClientLike, -} from '@/supabase' - -declare const encryptionClient: EncryptionClient -declare const supabaseClient: SupabaseClientLike - -const users = encryptedTable('users', { - email: types.TextSearch('email'), - amount: types.IntegerOrd('amount'), - createdAt: types.TimestampOrd('created_at'), - active: types.Boolean('active'), -}) - -type UserRow = { - id: number - email: string - amount: number - createdAt: Date - active: boolean - note: string -} - -const es = encryptedSupabaseV3({ encryptionClient, supabaseClient }) - -describe('encryptedSupabaseV3 typing', () => { - it('defaults rows to exactly InferPlaintext of the table', async () => { - const builder = es.from('users', users) - const { data } = await builder.select('id, email, amount') - - // Schema columns carry their domain plaintext types - expectTypeOf(data![0].email).toEqualTypeOf() - expectTypeOf(data![0].amount).toEqualTypeOf() - expectTypeOf(data![0].createdAt).toEqualTypeOf() - expectTypeOf(data![0].active).toEqualTypeOf() - }) - - it('narrows filter keys in the DEFAULT-Row case (no index-signature widening)', () => { - const builder = es.from('users', users) - - builder.eq('email', 'a@b.com') - builder.gte('amount', 10) - - // Storage-only column: excluded even without an explicit Row — the - // default Row is exactly InferPlaintext, so V3FilterableKeys stays narrow - // instead of collapsing to string. - // @ts-expect-error — storage-only column is excluded from filter keys - builder.eq('active', true) - - // Passthrough (non-schema) columns need an explicit Row to be filterable. - // @ts-expect-error — not a schema column; pass an explicit Row type - builder.eq('id', 1) - }) - - it('pins filter value types to the column plaintext with an explicit row type', () => { - const builder = es.from('users', users) - - builder.eq('email', 'a@b.com') - builder.gte('amount', 10) - builder.gte('createdAt', new Date()) - builder.eq('id', 1) - - // Wrong value type for a column - // @ts-expect-error — email is a string column - builder.eq('email', 42) - // @ts-expect-error — amount is a number column - builder.gte('amount', 'ten') - }) - - it('rejects filters on storage-only columns at the type level', () => { - const builder = es.from('users', users) - - // active is eql_v3.boolean — storage-only, not filterable - // @ts-expect-error — storage-only column is excluded from filter keys - builder.eq('active', true) - // @ts-expect-error — storage-only column is excluded from filter keys - builder.is('active', true) - // match() is FK-narrowed like every other filter method - builder.match({ email: 'a@b.com', amount: 3 }) - // @ts-expect-error — storage-only column is excluded from match() - builder.match({ active: true }) - }) - - it('accepts plaintext model values on insert', () => { - const builder = es.from('users', users) - - builder.insert({ email: 'a@b.com', amount: 3, createdAt: new Date() }) - builder.insert([{ email: 'a@b.com' }, { note: 'plain' }]) - - // @ts-expect-error — createdAt is a Date column - builder.insert({ createdAt: 'not-a-date' }) - }) - - it('resolves responses to the row type', () => { - const builder = es.from('users', users) - expectTypeOf(builder.select('id, email')).resolves.toEqualTypeOf< - EncryptedSupabaseResponse - >() - }) - - it('rejects a v2 schema', () => { - const v2Table = v2EncryptedTable('users', { - email: encryptedColumn('email').equality(), - }) - - // @ts-expect-error — encryptedSupabaseV3 only accepts v3 tables - es.from('users', v2Table) - }) -}) - -describe('encryptedSupabase (v2) typing is unchanged', () => { - it('keeps the single-generic builder shape', () => { - const esV2 = encryptedSupabase({ encryptionClient, supabaseClient }) - const v2Table = v2EncryptedTable('users', { - email: encryptedColumn('email').equality(), - }) - - type V2Row = { id: number; email: string } - const builder = esV2.from('users', v2Table) - expectTypeOf(builder).toEqualTypeOf>() - - builder.eq('email', 'a@b.com') - builder.eq('id', 1) - // @ts-expect-error — not a row key - builder.eq('missing', 1) - }) -}) diff --git a/packages/stack/__tests__/supabase-v3.test.ts b/packages/stack/__tests__/supabase-v3.test.ts deleted file mode 100644 index 9afd4e560..000000000 --- a/packages/stack/__tests__/supabase-v3.test.ts +++ /dev/null @@ -1,351 +0,0 @@ -import 'dotenv/config' - -import { createClient } from '@supabase/supabase-js' -import postgres from 'postgres' -import { afterAll, beforeAll, describe, expect, it } from 'vitest' -import { encryptedTable, types } from '@/eql/v3' -import { Encryption } from '@/index' -import { encryptedSupabaseV3 } from '@/supabase' -import { installEqlV3IfNeeded } from './helpers/eql-v3' - -// Mirror of supabase.test.ts for EQL v3 native domains. Needs a live Supabase -// project, so the suite is skipped unless SUPABASE_URL, SUPABASE_ANON_KEY, and -// DATABASE_URL are all set (plus the CS_* credentials Encryption() needs — -// same as every live suite). -// -// MANUAL PREREQUISITE (same class of step v2 needs for eql_v2): the `eql_v3` -// schema must be added to the Supabase dashboard's **Exposed schemas** -// (Settings → API → Exposed schemas). Without it the custom operators on the -// eql_v3.* domains are not on PostgREST's search_path and bare `col = term` -// filters silently fall back to base jsonb comparison — wrong results, no -// error. The grants themselves are applied automatically by -// installEqlV3IfNeeded below. -const SUPABASE_ENABLED = Boolean( - process.env.SUPABASE_URL && - process.env.SUPABASE_ANON_KEY && - process.env.DATABASE_URL, -) - -const supabase = SUPABASE_ENABLED - ? createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_ANON_KEY!) - : (undefined as unknown as ReturnType) - -// include_original: false on the match index is load-bearing for the live -// like/ilike tests: v3 filter operands are full storage envelopes (every -// eql_v3 domain CHECK requires the storage keys), and with include_original -// the operand's bloom would carry the whole pattern as an extra token that -// only matches when the pattern equals the stored value. -const table = encryptedTable('protect-ci-v3', { - email: types.TextSearch('email').freeTextSearch({ include_original: false }), - age: types.IntegerOrd('age'), - registeredAt: types.TimestampOrd('registered_at'), -}) - -type ProtectCiV3Row = { - id: number - email: string - age: number - registeredAt: Date - otherField: string - test_run_id: string -} - -const TEST_RUN_ID = `test-run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` - -const insertedIds: number[] = [] - -beforeAll(async () => { - if (!SUPABASE_ENABLED) return - - const sql = postgres(process.env.DATABASE_URL as string, { prepare: false }) - try { - // Supabase-aware install: opclass-stripped bundle + eql_v3 grants for the - // anon / authenticated / service_role roles. - await installEqlV3IfNeeded(sql, { supabase: true }) - - await sql` - CREATE TABLE IF NOT EXISTS "protect-ci-v3" ( - id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, - email eql_v3.text_search, - age eql_v3.integer_ord, - registered_at eql_v3.timestamp_ord, - "otherField" TEXT, - created_at TIMESTAMP DEFAULT NOW(), - test_run_id TEXT - ) - ` - await sql`GRANT ALL ON "protect-ci-v3" TO anon, authenticated, service_role` - await sql`NOTIFY pgrst, 'reload schema'` - } finally { - await sql.end() - } - - const { error } = await supabase - .from('protect-ci-v3') - .delete() - .eq('test_run_id', TEST_RUN_ID) - - if (error) { - console.warn(`[protect]: Failed to clean up test data: ${error.message}`) - } -}, 60000) - -afterAll(async () => { - if (!SUPABASE_ENABLED) return - if (insertedIds.length > 0) { - const { error } = await supabase - .from('protect-ci-v3') - .delete() - .in('id', insertedIds) - if (error) { - console.error(`[protect]: Failed to clean up test data: ${error.message}`) - } - } -}, 30000) - -describe.skipIf(!SUPABASE_ENABLED)( - 'supabase (encryptedSupabaseV3 wrapper, eql_v3 domains)', - () => { - async function makeInstance() { - const client = await Encryption({ schemas: [table] }) - return encryptedSupabaseV3({ - encryptionClient: client, - supabaseClient: supabase, - }) - } - - it('inserts and selects an encrypted text_search value', async () => { - const es = await makeInstance() - const plaintext = 'hello-v3@example.com' - - const { data: insertedData, error: insertError } = await es - .from('protect-ci-v3', table) - .insert({ email: plaintext, test_run_id: TEST_RUN_ID }) - .select('id') - - if (insertError) throw new Error(`[protect]: ${insertError.message}`) - insertedIds.push(insertedData![0].id) - - const { data, error } = await es - .from('protect-ci-v3', table) - .select('id, email') - .eq('id', insertedData![0].id) - - if (error) throw new Error(`[protect]: ${error.message}`) - expect(data).toHaveLength(1) - expect(data![0].email).toBe(plaintext) - }, 30000) - - it('round-trips a model including a Date column (reconstructRow parity)', async () => { - const es = await makeInstance() - const registeredAt = new Date('2026-03-04T05:06:07.000Z') - const model = { - email: 'dates-v3@example.com', - registeredAt, - otherField: 'not encrypted', - } - - const { data: insertedData, error: insertError } = await es - .from('protect-ci-v3', table) - .insert({ ...model, test_run_id: TEST_RUN_ID }) - .select('id') - - if (insertError) throw new Error(`[protect]: ${insertError.message}`) - insertedIds.push(insertedData![0].id) - - const { data, error } = await es - .from('protect-ci-v3', table) - .select('id, email, registeredAt, otherField') - .eq('id', insertedData![0].id) - - if (error) throw new Error(`[protect]: ${error.message}`) - expect(data).toHaveLength(1) - expect(data![0].email).toBe(model.email) - expect(data![0].otherField).toBe(model.otherField) - // Date columns are reconstructed from cast_as, not returned as strings - expect(data![0].registeredAt).toBeInstanceOf(Date) - expect(data![0].registeredAt.toISOString()).toBe( - registeredAt.toISOString(), - ) - }, 30000) - - it('inserts and selects bulk encrypted models', async () => { - const es = await makeInstance() - const models = [ - { email: 'bulk-v3-1@example.com', otherField: 'plain 1' }, - { email: 'bulk-v3-2@example.com', otherField: 'plain 2' }, - ] - - const { data: insertedData, error: insertError } = await es - .from('protect-ci-v3', table) - .insert(models.map((m) => ({ ...m, test_run_id: TEST_RUN_ID }))) - .select('id') - - if (insertError) throw new Error(`[protect]: ${insertError.message}`) - insertedIds.push(...insertedData!.map((d) => d.id)) - - const { data, error } = await es - .from('protect-ci-v3', table) - .select('id, email, otherField') - .in( - 'id', - insertedData!.map((d) => d.id), - ) - - if (error) throw new Error(`[protect]: ${error.message}`) - expect( - data!.map((d) => ({ email: d.email, otherField: d.otherField })), - ).toEqual(models) - }, 30000) - - it('filters a text_search column by equality (full-envelope operand)', async () => { - const es = await makeInstance() - const target = `eq-v3-${TEST_RUN_ID}@example.com` - - const { data: insertedData, error: insertError } = await es - .from('protect-ci-v3', table) - .insert([ - { email: target, test_run_id: TEST_RUN_ID }, - { - email: `other-${TEST_RUN_ID}@example.com`, - test_run_id: TEST_RUN_ID, - }, - ]) - .select('id') - - if (insertError) throw new Error(`[protect]: ${insertError.message}`) - insertedIds.push(...insertedData!.map((d) => d.id)) - - // The equality operand must satisfy the text_search domain CHECK - // (hm+ob+bf+ciphertext) — a narrowed hm-only term raises 23514. The - // adapter sends the full envelope; the eq operator matches by hmac. - const { data, error } = await es - .from('protect-ci-v3', table) - .select('id, email') - .eq('email', target) - .eq('test_run_id', TEST_RUN_ID) - - if (error) throw new Error(`[protect]: ${error.message}`) - expect(data).toHaveLength(1) - expect(data![0].email).toBe(target) - }, 30000) - - it('free-text searches a text_search column via like → cs (bloom containment)', async () => { - const es = await makeInstance() - const needle = `ftx${TEST_RUN_ID.slice(-6)}` - - const { data: insertedData, error: insertError } = await es - .from('protect-ci-v3', table) - .insert([ - { email: `alpha-${needle}@example.com`, test_run_id: TEST_RUN_ID }, - { email: `beta-nomatch@example.com`, test_run_id: TEST_RUN_ID }, - ]) - .select('id') - - if (insertError) throw new Error(`[protect]: ${insertError.message}`) - insertedIds.push(...insertedData!.map((d) => d.id)) - - const { data, error } = await es - .from('protect-ci-v3', table) - .select('id, email') - .like('email', needle) - .eq('test_run_id', TEST_RUN_ID) - - if (error) throw new Error(`[protect]: ${error.message}`) - expect(data).toHaveLength(1) - expect(data![0].email).toContain(needle) - }, 30000) - - it('filters an integer_ord column by equality', async () => { - const es = await makeInstance() - - const { data: insertedData, error: insertError } = await es - .from('protect-ci-v3', table) - .insert([ - { age: 37, test_run_id: TEST_RUN_ID }, - { age: 42, test_run_id: TEST_RUN_ID }, - ]) - .select('id') - - if (insertError) throw new Error(`[protect]: ${insertError.message}`) - insertedIds.push(...insertedData!.map((d) => d.id)) - - const { data, error } = await es - .from('protect-ci-v3', table) - .select('id, age') - .eq('age', 37) - .eq('test_run_id', TEST_RUN_ID) - - if (error) throw new Error(`[protect]: ${error.message}`) - expect(data).toHaveLength(1) - expect(data![0].age).toBe(37) - }, 30000) - - // First-of-its-kind coverage: the v2 suite historically had no encrypted - // range test on Supabase (a matching v2 range test now lives in - // supabase.test.ts). Real ORE terms require live ZeroKMS, hence the same - // env gating as the rest of the suite. Assert range FILTERING only — - // ORDER BY on the encrypted column is unsupported on Supabase (no - // operator families). - it('filters an integer_ord column by range (gte/lte)', async () => { - const es = await makeInstance() - - const { data: insertedData, error: insertError } = await es - .from('protect-ci-v3', table) - .insert([ - { age: 10, test_run_id: TEST_RUN_ID }, - { age: 25, test_run_id: TEST_RUN_ID }, - { age: 90, test_run_id: TEST_RUN_ID }, - ]) - .select('id') - - if (insertError) throw new Error(`[protect]: ${insertError.message}`) - insertedIds.push(...insertedData!.map((d) => d.id)) - - const { data, error } = await es - .from('protect-ci-v3', table) - .select('id, age') - .gte('age', 20) - .lte('age', 30) - .eq('test_run_id', TEST_RUN_ID) - - if (error) throw new Error(`[protect]: ${error.message}`) - expect(data).toHaveLength(1) - expect(data![0].age).toBe(25) - }, 30000) - - it('filters a timestamp_ord column by range with Date values', async () => { - const es = await makeInstance() - - const { data: insertedData, error: insertError } = await es - .from('protect-ci-v3', table) - .insert([ - { - registeredAt: new Date('2026-01-15T00:00:00.000Z'), - test_run_id: TEST_RUN_ID, - }, - { - registeredAt: new Date('2026-06-15T00:00:00.000Z'), - test_run_id: TEST_RUN_ID, - }, - ]) - .select('id') - - if (insertError) throw new Error(`[protect]: ${insertError.message}`) - insertedIds.push(...insertedData!.map((d) => d.id)) - - const { data, error } = await es - .from('protect-ci-v3', table) - .select('id, registeredAt') - .gte('registeredAt', new Date('2026-05-01T00:00:00.000Z')) - .eq('test_run_id', TEST_RUN_ID) - - if (error) throw new Error(`[protect]: ${error.message}`) - expect(data).toHaveLength(1) - expect(data![0].registeredAt).toBeInstanceOf(Date) - expect(data![0].registeredAt.toISOString()).toBe( - '2026-06-15T00:00:00.000Z', - ) - }, 30000) - }, -) diff --git a/packages/stack/__tests__/test-kit-env.test.ts b/packages/stack/__tests__/test-kit-env.test.ts new file mode 100644 index 000000000..191d80101 --- /dev/null +++ b/packages/stack/__tests__/test-kit-env.test.ts @@ -0,0 +1,129 @@ +import { mkdirSync, mkdtempSync, rmSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { requireIntegrationEnv } from '@cipherstash/test-kit' +import { afterEach, beforeEach, describe, expect, it } from 'vitest' + +/** + * The credential gate is the only thing between a rotated secret and a run that + * fails once per test with `[encryption]: Not authenticated`. It had no test. + * + * A partial environment — `CS_WORKSPACE_CRN` set, the client keys missing — used + * to pass, because the check was `if (CS_WORKSPACE_CRN) return true`. Reported by + * Copilot on #616, reproduced against a live suite, fixed here. + * + * `homedir()` reads `$HOME` on POSIX, so pointing `HOME` at a scratch directory + * controls whether a `~/.cipherstash` profile appears to exist. + */ +const CS_VARS = [ + 'CS_WORKSPACE_CRN', + 'CS_CLIENT_ID', + 'CS_CLIENT_KEY', + 'CS_CLIENT_ACCESS_KEY', +] as const + +let home: string +let saved: Record + +function setEnv(values: Partial>) { + for (const name of CS_VARS) delete process.env[name] + for (const [name, value] of Object.entries(values)) process.env[name] = value +} + +function withProfile() { + mkdirSync(join(home, '.cipherstash'), { recursive: true }) +} + +const ALL_FOUR = Object.fromEntries( + CS_VARS.map((name) => [name, `value-of-${name}`]), +) as Record<(typeof CS_VARS)[number], string> + +beforeEach(() => { + home = mkdtempSync(join(tmpdir(), 'cs-env-')) + saved = { HOME: process.env['HOME'] } + for (const name of CS_VARS) saved[name] = process.env[name] + process.env['HOME'] = home +}) + +afterEach(() => { + for (const [name, value] of Object.entries(saved)) { + if (value === undefined) delete process.env[name] + else process.env[name] = value + } + rmSync(home, { recursive: true, force: true }) +}) + +describe('requireIntegrationEnv — cipherstash credentials', () => { + it('accepts all four variables, with no profile', () => { + setEnv(ALL_FOUR) + + expect(() => requireIntegrationEnv(['cipherstash'])).not.toThrow() + }) + + it('accepts a profile with no variables', () => { + setEnv({}) + withProfile() + + expect(() => requireIntegrationEnv(['cipherstash'])).not.toThrow() + }) + + it('rejects a partial environment even when a profile exists', () => { + // The regression. `CS_WORKSPACE_CRN` alone used to satisfy the gate, and the + // run then died inside `encrypt()` rather than here. + setEnv({ CS_WORKSPACE_CRN: 'crn:ap-southeast-2.aws:ABC' }) + withProfile() + + expect(() => requireIntegrationEnv(['cipherstash'])).toThrow( + /PARTIALLY configured/, + ) + }) + + it('names exactly the missing variables', () => { + setEnv({ CS_WORKSPACE_CRN: 'crn', CS_CLIENT_ID: 'id' }) + + expect(() => requireIntegrationEnv(['cipherstash'])).toThrow( + /missing CS_CLIENT_KEY, CS_CLIENT_ACCESS_KEY/, + ) + }) + + it('rejects an empty environment with no profile, and offers both routes', () => { + setEnv({}) + + let message = '' + try { + requireIntegrationEnv(['cipherstash']) + } catch (cause) { + message = (cause as Error).message + } + + expect(message).toContain('none are configured') + expect(message).toContain('stash auth login') + expect(message).not.toContain('PARTIALLY') + }) + + it('treats an empty-string variable as missing, not as set', () => { + // A cleared GitHub secret expands to the empty string, not to unset. + setEnv({ ...ALL_FOUR, CS_CLIENT_KEY: '' }) + + expect(() => requireIntegrationEnv(['cipherstash'])).toThrow( + /missing CS_CLIENT_KEY/, + ) + }) + + it('reports every unmet requirement at once, not one per run', () => { + setEnv({}) + delete process.env['DATABASE_URL'] + delete process.env['PGRST_URL'] + + let message = '' + try { + requireIntegrationEnv(['cipherstash', 'database', 'pgrest']) + } catch (cause) { + message = (cause as Error).message + } + + expect(message).toContain('CipherStash credentials') + expect(message).toContain('DATABASE_URL') + expect(message).toContain('PGRST_URL') + }) +}) diff --git a/packages/stack/__tests__/test-kit-families.test.ts b/packages/stack/__tests__/test-kit-families.test.ts new file mode 100644 index 000000000..d94a3c2d3 --- /dev/null +++ b/packages/stack/__tests__/test-kit-families.test.ts @@ -0,0 +1,98 @@ +import { + deferredForFamily, + domainsForFamily, + eqlTypeSlug, + FAMILY_NAMES, + isCovered, + typedEntries, + V3_MATRIX, +} from '@cipherstash/test-kit' +import { describe, expect, it } from 'vitest' + +/** + * The integration suites are split one file per plaintext family, and each file + * asks `domainsForFamily(name)` which domains it owns. Nothing in that lookup + * forces the families to COVER the catalog: add a domain whose slug matches no + * family prefix (`interval_ord`, say) and it simply belongs to no file — the + * suites stay green while the domain goes untested. + * + * The catalog's `satisfies Record<…>` cannot catch that; it only forces a ROW to + * exist. These tests close the gap by asserting the families partition the + * catalog: every domain lands in exactly one family, and covered + deferred + * accounts for all of them. + */ +describe('test-kit families partition the v3 catalog', () => { + const bare = (eqlType: string) => eqlTypeSlug(eqlType).replace(/^eql_v3_/, '') + const allBare = typedEntries(V3_MATRIX).map(([eqlType]) => bare(eqlType)) + + it('assigns every covered domain to exactly one family', () => { + const owners = new Map() + for (const family of FAMILY_NAMES) { + for (const domain of domainsForFamily(family)) { + owners.set(domain.bare, [...(owners.get(domain.bare) ?? []), family]) + } + } + + const multiplyOwned = [...owners].filter(([, fams]) => fams.length > 1) + expect(multiplyOwned).toEqual([]) + + const coveredBare = typedEntries(V3_MATRIX) + .filter(([, spec]) => isCovered(spec)) + .map(([eqlType]) => bare(eqlType)) + .sort() + + expect([...owners.keys()].sort()).toEqual(coveredBare) + }) + + it('accounts for every catalog domain as covered or deferred', () => { + const covered = FAMILY_NAMES.flatMap((f) => + domainsForFamily(f).map((d) => d.bare), + ) + const deferred = FAMILY_NAMES.flatMap((f) => + deferredForFamily(f).map((d) => d.bare), + ) + + expect([...covered, ...deferred].sort()).toEqual([...allBare].sort()) + }) + + it('defers the block-ORE domains and json, each with a reason', () => { + const deferred = FAMILY_NAMES.flatMap((f) => deferredForFamily(f)) + + expect(deferred.map((d) => d.bare).sort()).toEqual([ + 'bigint_ord_ore', + 'date_ord_ore', + 'double_ord_ore', + 'integer_ord_ore', + 'json', + 'numeric_ord_ore', + 'real_ord_ore', + 'smallint_ord_ore', + 'text_ord_ore', + 'timestamp_ord_ore', + ]) + // ORE domains defer for the superuser-only opclass; json defers because it + // is queried by containment, not the scalar op-matrix (covered by dedicated + // suites — see catalog reason). + for (const { bare, reason } of deferred) { + expect(reason).toMatch(bare === 'json' ? /containment/ : /superuser-only/) + } + }) + + it('never hands a family a domain from a neighbouring prefix', () => { + // `date` must not claim `timestamp_ord`, and `integer` must not claim + // `smallint`. The prefix match is anchored on `_` or end-of-string; a naive + // `startsWith` would fail this. + expect(domainsForFamily('date').map((d) => d.bare)).toEqual([ + 'date', + 'date_eq', + 'date_ord', + ]) + expect(domainsForFamily('text').map((d) => d.bare)).toEqual([ + 'text', + 'text_eq', + 'text_match', + 'text_ord', + 'text_search', + ]) + }) +}) diff --git a/packages/stack/__tests__/typed-client-v3.test.ts b/packages/stack/__tests__/typed-client-v3.test.ts index c605cdec2..5969989b7 100644 --- a/packages/stack/__tests__/typed-client-v3.test.ts +++ b/packages/stack/__tests__/typed-client-v3.test.ts @@ -86,4 +86,40 @@ describe('typedClient — decrypt reconstruction', () => { const result = await client.decryptModel({}, table) expect(result.failure).toBeTruthy() }) + + it('fails with a DecryptionError when given a table it was not initialized with', async () => { + const other = encryptedTable('other', { x: types.Text('x') }) + const client = typedClient(fakeClient({ when: null }), table) + + const single = await client.decryptModel({}, other as never) + expect(single.failure?.type).toBe('DecryptionError') + expect(single.failure?.message).toMatch(/not initialized with/i) + + const bulk = await client.bulkDecryptModels([{}], other as never) + expect(bulk.failure?.type).toBe('DecryptionError') + }) + + // Reconstructors are keyed by `tableName`, not object identity: a table + // re-imported from another module (or rebuilt across an HMR reload) is a + // distinct object that still satisfies `Table extends S[number]`. + it('decrypts when handed a structurally identical, separately constructed table', async () => { + const sameTableRebuilt = encryptedTable('t', { + when: types.Timestamp('when'), + note: types.Text('note'), + createdOn: types.Date('created_on'), + }) + expect(sameTableRebuilt).not.toBe(table) + + const client = typedClient( + fakeClient({ when: '2020-01-02T03:04:05.000Z', note: 'hi' }), + table, + ) + + const result = await client.decryptModel({}, sameTableRebuilt) + expect(result.failure).toBeFalsy() + if (result.failure) return + + const data = result.data as Record + expect(data.when).toBeInstanceOf(Date) + }) }) diff --git a/packages/stack/__tests__/v3-matrix/catalog.ts b/packages/stack/__tests__/v3-matrix/catalog.ts index 994d9a227..6077d63cc 100644 --- a/packages/stack/__tests__/v3-matrix/catalog.ts +++ b/packages/stack/__tests__/v3-matrix/catalog.ts @@ -1,255 +1,11 @@ /** - * Type-driven v3 test matrix — single source of truth. + * The v3 domain catalog moved to `@cipherstash/test-kit` so the integration + * suites — which after the adapter split live in other packages — can import + * the same single source of truth. A package must not reach into another + * package's `__tests__` tree, and duplicating the catalog would let the two + * copies disagree about which domains exist. * - * The TypeScript analog of the Rust `eql_v3` `scalar_matrix!` harness - * (`encrypt-query-language/tests/sqlx`): one declarative catalog drives both a - * runtime `it.each` matrix (`matrix.test.ts`) and type-level assertions - * (`matrix.test-d.ts`), instead of hand-rolling per-domain test bodies. - * - * COVERAGE IS MANDATORY. The catalog is `satisfies Record`, and `EqlV3TypeName` is derived from the real column union - * (`AnyEncryptedV3Column`). Add a domain to the SDK and this file fails to - * compile until it has a row — the compile-time analog of, and stronger than, - * the Rust `test:matrix:inventory` cross-check (it names each missing domain). - * - * Every field here is consumed by a test: `builder`/`ColumnClass` by the - * instanceof check, `castAs` + `indexes` by the `build()` `toStrictEqual`, and - * `capabilities` by `getQueryCapabilities()`/`isQueryable()`. - */ - -import type { - AnyEncryptedV3Column, - EqlTypeForColumn, - QueryCapabilities, -} from '@/eql/v3' -import { - EncryptedBooleanColumn, - EncryptedDateColumn, - EncryptedDateEqColumn, - EncryptedDateOrdColumn, - EncryptedDateOrdOreColumn, - EncryptedRealColumn, - EncryptedRealEqColumn, - EncryptedRealOrdColumn, - EncryptedRealOrdOreColumn, - EncryptedDoubleColumn, - EncryptedDoubleEqColumn, - EncryptedDoubleOrdColumn, - EncryptedDoubleOrdOreColumn, - EncryptedSmallintColumn, - EncryptedSmallintEqColumn, - EncryptedSmallintOrdColumn, - EncryptedSmallintOrdOreColumn, - EncryptedIntegerColumn, - EncryptedIntegerEqColumn, - EncryptedIntegerOrdColumn, - EncryptedIntegerOrdOreColumn, - EncryptedNumericColumn, - EncryptedNumericEqColumn, - EncryptedNumericOrdColumn, - EncryptedNumericOrdOreColumn, - EncryptedTextColumn, - EncryptedTextEqColumn, - EncryptedTextMatchColumn, - EncryptedTextOrdColumn, - EncryptedTextOrdOreColumn, - EncryptedTextSearchColumn, - EncryptedTimestampColumn, - EncryptedTimestampEqColumn, - EncryptedTimestampOrdColumn, - EncryptedTimestampOrdOreColumn, - types, -} from '@/eql/v3' -import type { ColumnSchema } from '@/schema' - -/** - * The canonical union of every v3 domain name — derived STRAIGHT from the real - * column union (`AnyEncryptedV3Column`) via the exported `EqlTypeForColumn` - * helper, not hand-copied. This is the key set the `Record` below must cover. - */ -export type EqlV3TypeName = EqlTypeForColumn - -/** One row of the type-driven matrix: everything a test needs about a domain. */ -export type DomainSpec = Readonly<{ - /** Column builder under test. */ - builder: (name: string) => AnyEncryptedV3Column - /** Concrete class the builder must instantiate (`toBeInstanceOf`). */ - ColumnClass: new ( - ...args: never[] - ) => AnyEncryptedV3Column - /** Plaintext axis emitted by `build().cast_as`. */ - castAs: ColumnSchema['cast_as'] - /** Semantic capability flags (`getQueryCapabilities()`). */ - capabilities: QueryCapabilities - /** - * The full `build().indexes` output — stored as DATA per row (like the Rust - * harness) rather than derived from `capabilities`, because `text_search` - * overrides `build()` to emit `unique + ore + match` where the capability → - * index rule would omit `unique` for an order-capable column. - */ - indexes: ColumnSchema['indexes'] - /** - * Representative + edge plaintext values that MUST round-trip through live - * encrypt/decrypt (consumed by `matrix-live.test.ts`). Typed as the loose - * plaintext union rather than per-row: the precise `castAs → plaintext` axis - * is already proven at the type level in `matrix.test-d.ts` (`InferPlaintext`), - * and a per-row generic would break the single `satisfies Record<…>` that is - * this file's coverage mechanism. Numeric samples are split integer-vs- - * fractional: `build()` emits `cast_as:'number'` uniformly so the FFI can't - * tell `integer` from `double`, and a fractional value on an int-named domain is - * untested territory (it would truncate against a real narrow PG column). - */ - samples: ReadonlyArray - /** - * Values that MUST fail encryption. Number domains reject `NaN`/`±Infinity` - * via a global guard; other domains omit this. - */ - errorSamples?: ReadonlyArray -}> - -/** - * `Object.entries` that preserves the literal key union instead of widening to - * `string` — so `eqlType` in the runtime matrix stays `EqlV3TypeName`. + * This shim keeps the ~12 unit suites that import `../v3-matrix/catalog` + * unchanged. Import from `@cipherstash/test-kit` in anything new. */ -export function typedEntries( - obj: Record, -): Array<[K, V]> { - return Object.entries(obj) as Array<[K, V]> -} - -// Capability shorthands (mirror the SDK's internal presets). -const STORAGE = { - equality: false, - orderAndRange: false, - freeTextSearch: false, -} as const -const EQ = { - equality: true, - orderAndRange: false, - freeTextSearch: false, -} as const -const ORD = { - equality: true, - orderAndRange: true, - freeTextSearch: false, -} as const -const MATCH_ONLY = { - equality: false, - orderAndRange: false, - freeTextSearch: true, -} as const -const FULL = { - equality: true, - orderAndRange: true, - freeTextSearch: true, -} as const - -// Index shorthands (mirror `build().indexes`). Type-annotated rather than -// `as const`: annotation contextually types the literals so enum fields like -// `kind: 'ngram'` stay checked against the schema while arrays remain MUTABLE -// — `ColumnSchema['indexes']` rejects the `readonly` arrays `as const` produces. -type Indexes = ColumnSchema['indexes'] -const NONE: Indexes = {} -const UNIQUE_IDX: Indexes = { unique: { token_filters: [] } } -const ORE_IDX: Indexes = { ore: {} } -// Text order domains (`text_ord`, `text_ord_ore`) carry BOTH `hm` (unique) and -// `ob` (ore): their eql_v3 SQL domains require `hm` because text equality is -// HMAC-based, unlike numeric/date order domains which answer equality via `ob`. -const TEXT_ORD_IDX: Indexes = { unique: { token_filters: [] }, ore: {} } -const MATCH_BLOCK: NonNullable['match'] = { - tokenizer: { kind: 'ngram', token_length: 3 }, - token_filters: [{ kind: 'downcase' }], - k: 6, - m: 2048, - include_original: true, -} -const MATCH_IDX: Indexes = { match: MATCH_BLOCK } -const TEXT_SEARCH_IDX: Indexes = { - unique: { token_filters: [] }, - ore: {}, - match: MATCH_BLOCK, -} - -// Sample plaintexts per plaintext axis, consumed by `matrix-live.test.ts`. -// Numeric sets are split by domain width: integers (incl. type bounds) for -// smallint/integer, fractionals for real/double/numeric. See `DomainSpec.samples`. -const SMALLINT_S = [0, -1, 32767, -32768] as const -const INTEGER_S = [0, -42, 2147483647, -2147483648] as const -const REAL_S = [0, 77.5, -117.25, 0.5] as const -const DOUBLE_S = [0, -117.123456, 1e15, -1e15] as const -const NUMERIC_S = [0, 12345.678, -42, -0.5] as const -const TEXT_S = ['', 'ada@example.com', 'Ada Lovelace'] as const -// Samples for the ob-carrying text domains (text_ord, text_ord_ore, -// text_search). These CANNOT include '' like TEXT_S: their eql_v3 SQL domain -// CHECKs demand a non-empty ore term (`jsonb_array_length(VALUE->'ob') > 0`), -// and the ORE term of the empty string has zero blocks — storing '' in one of -// these domains is rejected by Postgres with a check-constraint violation -// (observed live: matrix-live-pg's seed INSERT failed `text_ord_ore_check`). -// The '' edge stays covered where it IS storable: text, text_eq, text_match. -// Row-A/row-B constraints preserved: samples[0] ≠ samples[1] (ord equality -// proof selects row A only), and the match proof's 'ada' substring occurs in -// samples[1] only (text_search match proof targets row B). -const TEXT_ORD_S = [ - 'grace@example.net', - 'ada@example.com', - 'Ada Lovelace', -] as const -const BOOLEAN_S = [true, false] as const -const DATE_S = [ - new Date('2026-07-01T00:00:00.000Z'), - new Date('1970-01-01T00:00:00.000Z'), -] as const -// Every number domain rejects these via the global encrypt guard. -const NUM_ERR = [ - Number.NaN, - Number.POSITIVE_INFINITY, - Number.NEGATIVE_INFINITY, -] as const - -// biome-ignore format: one row per domain reads as a table; keep it dense. -export const V3_MATRIX = { - // integer - 'eql_v3.integer': { builder: types.Integer, ColumnClass: EncryptedIntegerColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: INTEGER_S, errorSamples: NUM_ERR }, - 'eql_v3.integer_eq': { builder: types.IntegerEq, ColumnClass: EncryptedIntegerEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: INTEGER_S, errorSamples: NUM_ERR }, - 'eql_v3.integer_ord_ore': { builder: types.IntegerOrdOre, ColumnClass: EncryptedIntegerOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INTEGER_S, errorSamples: NUM_ERR }, - 'eql_v3.integer_ord': { builder: types.IntegerOrd, ColumnClass: EncryptedIntegerOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INTEGER_S, errorSamples: NUM_ERR }, - // smallint - 'eql_v3.smallint': { builder: types.Smallint, ColumnClass: EncryptedSmallintColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: SMALLINT_S, errorSamples: NUM_ERR }, - 'eql_v3.smallint_eq': { builder: types.SmallintEq, ColumnClass: EncryptedSmallintEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, - 'eql_v3.smallint_ord_ore': { builder: types.SmallintOrdOre, ColumnClass: EncryptedSmallintOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, - 'eql_v3.smallint_ord': { builder: types.SmallintOrd, ColumnClass: EncryptedSmallintOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, - // date - 'eql_v3.date': { builder: types.Date, ColumnClass: EncryptedDateColumn, castAs: 'date', capabilities: STORAGE, indexes: NONE, samples: DATE_S }, - 'eql_v3.date_eq': { builder: types.DateEq, ColumnClass: EncryptedDateEqColumn, castAs: 'date', capabilities: EQ, indexes: UNIQUE_IDX, samples: DATE_S }, - 'eql_v3.date_ord_ore': { builder: types.DateOrdOre, ColumnClass: EncryptedDateOrdOreColumn, castAs: 'date', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, - 'eql_v3.date_ord': { builder: types.DateOrd, ColumnClass: EncryptedDateOrdColumn, castAs: 'date', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, - // timestamp - 'eql_v3.timestamp': { builder: types.Timestamp, ColumnClass: EncryptedTimestampColumn, castAs: 'timestamp', capabilities: STORAGE, indexes: NONE, samples: DATE_S }, - 'eql_v3.timestamp_eq': { builder: types.TimestampEq, ColumnClass: EncryptedTimestampEqColumn, castAs: 'timestamp', capabilities: EQ, indexes: UNIQUE_IDX, samples: DATE_S }, - 'eql_v3.timestamp_ord_ore': { builder: types.TimestampOrdOre, ColumnClass: EncryptedTimestampOrdOreColumn, castAs: 'timestamp', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, - 'eql_v3.timestamp_ord': { builder: types.TimestampOrd, ColumnClass: EncryptedTimestampOrdColumn, castAs: 'timestamp', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, - // numeric - 'eql_v3.numeric': { builder: types.Numeric, ColumnClass: EncryptedNumericColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: NUMERIC_S, errorSamples: NUM_ERR }, - 'eql_v3.numeric_eq': { builder: types.NumericEq, ColumnClass: EncryptedNumericEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, - 'eql_v3.numeric_ord_ore': { builder: types.NumericOrdOre, ColumnClass: EncryptedNumericOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, - 'eql_v3.numeric_ord': { builder: types.NumericOrd, ColumnClass: EncryptedNumericOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, - // text - 'eql_v3.text': { builder: types.Text, ColumnClass: EncryptedTextColumn, castAs: 'string', capabilities: STORAGE, indexes: NONE, samples: TEXT_S }, - 'eql_v3.text_eq': { builder: types.TextEq, ColumnClass: EncryptedTextEqColumn, castAs: 'string', capabilities: EQ, indexes: UNIQUE_IDX, samples: TEXT_S }, - 'eql_v3.text_match': { builder: types.TextMatch, ColumnClass: EncryptedTextMatchColumn, castAs: 'string', capabilities: MATCH_ONLY, indexes: MATCH_IDX, samples: TEXT_S }, - 'eql_v3.text_ord_ore': { builder: types.TextOrdOre, ColumnClass: EncryptedTextOrdOreColumn, castAs: 'string', capabilities: ORD, indexes: TEXT_ORD_IDX, samples: TEXT_ORD_S }, - 'eql_v3.text_ord': { builder: types.TextOrd, ColumnClass: EncryptedTextOrdColumn, castAs: 'string', capabilities: ORD, indexes: TEXT_ORD_IDX, samples: TEXT_ORD_S }, - 'eql_v3.text_search': { builder: types.TextSearch, ColumnClass: EncryptedTextSearchColumn, castAs: 'string', capabilities: FULL, indexes: TEXT_SEARCH_IDX, samples: TEXT_ORD_S }, - // boolean - 'eql_v3.boolean': { builder: types.Boolean, ColumnClass: EncryptedBooleanColumn, castAs: 'boolean', capabilities: STORAGE, indexes: NONE, samples: BOOLEAN_S }, - // real - 'eql_v3.real': { builder: types.Real, ColumnClass: EncryptedRealColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: REAL_S, errorSamples: NUM_ERR }, - 'eql_v3.real_eq': { builder: types.RealEq, ColumnClass: EncryptedRealEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: REAL_S, errorSamples: NUM_ERR }, - 'eql_v3.real_ord_ore': { builder: types.RealOrdOre, ColumnClass: EncryptedRealOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: REAL_S, errorSamples: NUM_ERR }, - 'eql_v3.real_ord': { builder: types.RealOrd, ColumnClass: EncryptedRealOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: REAL_S, errorSamples: NUM_ERR }, - // double - 'eql_v3.double': { builder: types.Double, ColumnClass: EncryptedDoubleColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: DOUBLE_S, errorSamples: NUM_ERR }, - 'eql_v3.double_eq': { builder: types.DoubleEq, ColumnClass: EncryptedDoubleEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, - 'eql_v3.double_ord_ore': { builder: types.DoubleOrdOre, ColumnClass: EncryptedDoubleOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, - 'eql_v3.double_ord': { builder: types.DoubleOrd, ColumnClass: EncryptedDoubleOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, -} as const satisfies Record +export * from '@cipherstash/test-kit/catalog' diff --git a/packages/stack/__tests__/v3-matrix/matrix-identity-live.test.ts b/packages/stack/__tests__/v3-matrix/matrix-identity-live.test.ts deleted file mode 100644 index 8f0477063..000000000 --- a/packages/stack/__tests__/v3-matrix/matrix-identity-live.test.ts +++ /dev/null @@ -1,65 +0,0 @@ -/** - * Live identity-aware coverage for the v3 typed client: lock-context round-trips - * and audit metadata. Kept separate from `matrix-lock-context.test.ts` because - * that file mocks `@cipherstash/protect-ffi` file-wide — a mock would neutralize - * a "live" assertion. No mock here: these hit a real CipherStash workspace and - * soft-skip when credentials (and, for lock context, `USER_JWT`) are absent, - * mirroring the v2 `audit.test.ts` / lock-context pattern. - */ -import 'dotenv/config' -import { beforeAll, describe, expect, it } from 'vitest' -import { EncryptionV3, encryptedTable, types } from '@/encryption/v3' -import { LockContext } from '@/identity' -import { unwrapResult } from '../fixtures' -import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' - -const users = encryptedTable('v3_identity_live_users', { - email: types.TextEq('email'), -}) - -describeLive('v3 typed client identity-aware operations (live)', () => { - let client: Awaited>> - - beforeAll(async () => { - client = await EncryptionV3({ schemas: [users] }) - }, 30000) - - it('round-trips a model with a lock context (encrypt + decrypt bound to identity)', async () => { - const userJwt = process.env.USER_JWT - if (!userJwt) { - console.log('Skipping lock context test - no USER_JWT provided') - return - } - - const lc = new LockContext() - const lockContext = await lc.identify(userJwt) - if (lockContext.failure) { - throw new Error(`[protect]: ${lockContext.failure.message}`) - } - - const encrypted = unwrapResult( - await client - .encryptModel({ email: 'ada@example.com' }, users) - .withLockContext(lockContext.data), - ) - expect(encrypted.email).toHaveProperty('c') - - // decryptModel takes the lock context as a positional 3rd arg. - const decrypted = unwrapResult( - await client.decryptModel(encrypted, users, lockContext.data), - ) - expect(decrypted.email).toBe('ada@example.com') - }, 30000) - - it('accepts .audit({ metadata }) on the encrypt path and still round-trips', async () => { - const encrypted = unwrapResult( - await client - .encrypt('secret@example.com', { table: users, column: users.email }) - .audit({ metadata: { sub: 'toby@cipherstash.com', type: 'encrypt' } }), - ) - expect(encrypted).toHaveProperty('c') - - const decrypted = unwrapResult(await client.decrypt(encrypted)) - expect(decrypted).toBe('secret@example.com') - }, 30000) -}) diff --git a/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts b/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts deleted file mode 100644 index bd1343bfa..000000000 --- a/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts +++ /dev/null @@ -1,301 +0,0 @@ -/** - * Live Postgres coverage for ALL 35 v3 domains — one query-correctness proof - * per domain, dispatched by capability tier, against a real installed eql_v3 - * extension. - * - * `matrix-live.test.ts` proves every domain round-trips through live FFI - * ciphertext, but never touches SQL. `schema-v3-pg.test.ts` proves real SQL - * query behaviour, but only for 4 hand-picked domains. Neither is redundant - * with this file: the equality-via-ORE fix (`infer-index-type.ts`) shows an - * SDK-side bug can hide behind a clean FFI round-trip and only surface - * against real Postgres — defence in depth means every domain gets that - * proof, not just a representative few. This file also doubles as one - * canonical, runnable example per capability tier of how to actually query - * each kind of v3 domain in SQL — useful reference for engineers and agents - * writing new domain-consuming code. - * - * ONE mega table (all 35 domains, one column each, like `matrix-live.test.ts`), - * two seeded rows (`samples[0]` / `samples[1]` from the catalog — every domain - * has at least two), one query per domain proving it selects the expected row - * and not the other. Dispatch mirrors the priority `resolveIndexType` itself - * uses (match > unique > ore > none): - * - match (text_match, text_search): `eql_v3.match_term` + `bloom_filter` - * - eq (*_eq domains): `eql_v3.eq_term` + `hmac_256` - * - ord (*_ord / *_ord_ore domains): `eql_v3.ord_term` + `ore_block_256`, - * queried with `queryType:'equality'` — the exact path Part A fixed. Most - * ord-tier domains (all but text) have no `eq_term` at all in the real - * `eql_v3` SQL (verified against the fixture), so this is not a stylistic - * choice: it is the only equality path that exists for them. - * - storage (no index): no query is possible; proves the ciphertext, cast to - * THIS SPECIFIC Postgres domain type, survives a real INSERT/SELECT and - * still decrypts — the one thing the FFI-only round-trip can't show. - */ -import 'dotenv/config' -import postgres from 'postgres' -import { afterAll, beforeAll, describe, expect, it } from 'vitest' -import { Encryption } from '@/encryption' -import { EncryptionV3, encryptedTable } from '@/encryption/v3' -import { unwrapResult } from '../fixtures' -import { assertV3WireEnvelope, installEqlV3IfNeeded } from '../helpers/eql-v3' -import { describeLivePg, LIVE_EQL_V3_PG_ENABLED } from '../helpers/live-gate' -import { - type DomainSpec, - type EqlV3TypeName, - typedEntries, - V3_MATRIX, -} from './catalog' - -// Previously force-skipped (CI run 28569708268, PR #540): `beforeAll` crashed -// with `PostgresError: invalid input syntax for type json` on the dynamic -// 35-column INSERT. Root cause was a postgres.js serialization gap — a bare -// ciphertext object stringified to `"[object Object]"` — now fixed by wrapping -// every INSERT param in `sql.json(...)` (see `beforeAll`; the fix landed right -// after the skip and the skip was simply left stale). Re-enabled here as an -// ordinary credential-gated suite: it runs in CI (which supplies DATABASE_URL + -// CS_* creds) and self-skips locally when they are absent. - -const databaseUrl = process.env.DATABASE_URL -const sql = LIVE_EQL_V3_PG_ENABLED - ? postgres(databaseUrl as string, { prepare: false }) - : (undefined as unknown as postgres.Sql) - -const TABLE_NAME = 'v3_matrix_live_pg' -const TEST_RUN_ID = `matrix-live-pg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` - -/** `eql_v3.integer_ord` -> `integer_ord`: a valid, unique Postgres column name. */ -const slug = (t: EqlV3TypeName): string => t.replace('eql_v3.', '') - -const domains = typedEntries(V3_MATRIX) - -const columns = Object.fromEntries( - domains.map(([t, spec]) => [slug(t), spec.builder(slug(t))]), -) -const table = encryptedTable(TABLE_NAME, columns as never) - -/** - * The one proof each domain's configured indexes call for — mirrors the - * priority `resolveIndexType`/`inferIndexType` themselves use: match wins over - * unique wins over ore. `text_search` carries all three but gets the match - * proof (its distinguishing, richest capability); the plain `*_eq` domains get - * the eq proof; every `*_ord`/`*_ord_ore` domain (including the text ones, - * which also have an `eq_term` but are queried the same way as their - * non-text siblings for consistency) gets the equality-via-ORE proof. - */ -type ProofKind = 'match' | 'eq' | 'ord' | 'storage' -function proofKindFor(indexes: DomainSpec['indexes']): ProofKind { - const idx = indexes ?? {} - if (idx.match) return 'match' - if (idx.unique) return 'eq' - if (idx.ore) return 'ord' - return 'storage' -} - -const matchDomains = domains.filter( - ([, spec]) => proofKindFor(spec.indexes) === 'match', -) -const eqDomains = domains.filter( - ([, spec]) => proofKindFor(spec.indexes) === 'eq', -) -const ordDomains = domains.filter( - ([, spec]) => proofKindFor(spec.indexes) === 'ord', -) -const storageDomains = domains.filter( - ([, spec]) => proofKindFor(spec.indexes) === 'storage', -) - -type Row = { id: number } - -let client: Awaited> -let termClient: Awaited> -let idA: number -let idB: number -// Query terms, pre-encrypted once in `beforeAll` (not per `it.each` case). -const eqTerms: Record = {} -const ordTerms: Record = {} -const matchTerms: Record = {} - -beforeAll(async () => { - if (!LIVE_EQL_V3_PG_ENABLED) return - - await installEqlV3IfNeeded(sql) - client = await EncryptionV3({ schemas: [table] as never }) - // INTERIM (CIP-3402): protect-ffi 0.27 has no v3 scalar query wire shape — - // scalar encryptQuery on the v3-wire client throws EQL_V3_QUERY_UNSUPPORTED. - // Query terms come from a second, explicitly v2-wire client: the - // eql_v3_internal extractors below read only the term keys from the jsonb, - // and index terms are identical across wire formats. - termClient = await Encryption({ - schemas: [table] as never, - config: { eqlVersion: 2 }, - }) - - const columnDefs = domains - .map(([t]) => `"${slug(t)}" ${t} NOT NULL`) - .join(',\n ') - - await sql.unsafe(` - CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( - id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, - test_run_id TEXT NOT NULL, - ${columnDefs} - ) - `) - - // Two model rows: row A carries samples[0], row B carries samples[1], for - // every domain — every catalog `samples` array has at least two entries. - const rowA: Record = {} - const rowB: Record = {} - for (const [t, spec] of domains) { - rowA[slug(t)] = spec.samples[0] - rowB[slug(t)] = spec.samples[1] - } - - const [encA, encB] = unwrapResult( - await client.bulkEncryptModels([rowA, rowB] as never, table as never), - ) as Array> - - // Generation handshake: fail loudly on client/bundle wire-format skew - // before the 35-column INSERT turns it into an opaque 23514. - for (const [name, value] of Object.entries(encA)) { - assertV3WireEnvelope(value, `matrix-live-pg seed column ${name}`) - } - - const colNames = domains.map(([t]) => `"${slug(t)}"`) - const insertRow = async (enc: Record): Promise => { - const casts = domains.map(([t], i) => `$${i + 2}::${t}`) - // `sql.json(...)` (not the bare ciphertext object): postgres.js only infers - // an explicit wire type for `Parameter`/`Date`/`Uint8Array`/boolean/bigint — - // a plain object falls through to `'' + x` (`Bind()` in - // postgres/src/connection.js), i.e. the literal string `"[object Object]"`, - // which Postgres rejects as invalid JSON before the domain cast ever runs. - const values = domains.map(([t]) => sql.json(enc[slug(t)] as never)) - const [row] = await sql.unsafe( - `INSERT INTO ${TABLE_NAME} (test_run_id, ${colNames.join(', ')}) - VALUES ($1, ${casts.join(', ')}) - RETURNING id`, - [TEST_RUN_ID, ...values], - ) - return row.id - } - idA = await insertRow(encA) - idB = await insertRow(encB) - - const columnRef = (t: EqlV3TypeName) => - (table as unknown as Record)[slug(t)] as never - - // The full `opts` object (not just `column`) is cast `as never`: `encryptQuery` - // derives its allowed `queryType` union FROM the column's type - // (`QueryTypesForColumn`), so a `never`-typed `column` alone collapses - // `queryType` to `undefined` rather than widening it — this table's columns - // are built dynamically (`Object.fromEntries`), so none of them carry a - // statically-known type for `encryptQuery` to key off in the first place. - for (const [t, spec] of eqDomains) { - eqTerms[slug(t)] = unwrapResult( - await termClient.encryptQuery( - spec.samples[0] as never, - { - table, - column: columnRef(t), - queryType: 'equality', - } as never, - ), - ) - } - for (const [t, spec] of ordDomains) { - ordTerms[slug(t)] = unwrapResult( - await termClient.encryptQuery( - spec.samples[0] as never, - { - table, - column: columnRef(t), - queryType: 'equality', - } as never, - ), - ) - } - // text_match/text_search: query a substring of row B's sample. Row A's - // shared `TEXT_S[0]` is `''` — a degenerate containment target — so the - // match proof targets row B instead of the usual row A. - for (const [t] of matchDomains) { - matchTerms[slug(t)] = unwrapResult( - await termClient.encryptQuery( - 'ada' as never, - { - table, - column: columnRef(t), - queryType: 'freeTextSearch', - } as never, - ), - ) - } -}, 120000) - -afterAll(async () => { - if (!LIVE_EQL_V3_PG_ENABLED) return - await sql.unsafe(`DELETE FROM ${TABLE_NAME} WHERE test_run_id = $1`, [ - TEST_RUN_ID, - ]) - await sql.end() -}, 30000) - -describeLivePg('v3 matrix live Postgres coverage (all 35 domains)', () => { - it.each( - eqDomains, - )('%s: eq_term/hmac_256 selects the exact row', async (eqlType) => { - const col = slug(eqlType) - const rows = await sql.unsafe( - `SELECT id FROM ${TABLE_NAME} - WHERE test_run_id = $1 - AND eql_v3.eq_term("${col}") = eql_v3_internal.hmac_256($2::jsonb)`, - [TEST_RUN_ID, sql.json(eqTerms[col] as never)], - ) - expect(rows.map((r) => r.id)).toEqual([idA]) - }) - - it.each( - ordDomains, - )('%s: ord_term/ore_block_256 equality-via-ORE selects the exact row', async (eqlType) => { - const col = slug(eqlType) - const rows = await sql.unsafe( - `SELECT id FROM ${TABLE_NAME} - WHERE test_run_id = $1 - AND eql_v3.ord_term("${col}") = eql_v3_internal.ore_block_256($2::jsonb)`, - [TEST_RUN_ID, sql.json(ordTerms[col] as never)], - ) - expect(rows.map((r) => r.id)).toEqual([idA]) - }) - - it.each( - matchDomains, - )('%s: match_term/bloom_filter selects row B (containing "ada"), not row A', async (eqlType) => { - const col = slug(eqlType) - const rows = await sql.unsafe( - `SELECT id FROM ${TABLE_NAME} - WHERE test_run_id = $1 - AND eql_v3.match_term("${col}") @> eql_v3_internal.bloom_filter($2::jsonb)`, - [TEST_RUN_ID, sql.json(matchTerms[col] as never)], - ) - expect(rows.map((r) => r.id)).toEqual([idB]) - }) - - it.each( - storageDomains, - )('%s: ciphertext survives a real INSERT/SELECT and still decrypts', async (eqlType, spec) => { - const col = slug(eqlType) - const [row] = await sql.unsafe>( - `SELECT "${col}"::jsonb AS value FROM ${TABLE_NAME} WHERE id = $1`, - [idA], - ) - const decrypted = unwrapResult(await client.decrypt(row.value as never)) - const expected = spec.samples[0] - if (expected instanceof Date) { - // Lone-ciphertext decrypt has no column identity, so the cast_as-driven - // Date reconstruction (a decrypt-MODEL feature) cannot apply — the FFI - // returns the serialized instant (e.g. '2026-07-01T00:00:00Z'). Parse - // before comparing; toEqual on Dates compares the time value. - expect(new Date(decrypted as string)).toEqual(expected) - } else { - expect(decrypted).toBe(expected) - } - }) -}) diff --git a/packages/stack/__tests__/v3-matrix/matrix.test-d.ts b/packages/stack/__tests__/v3-matrix/matrix.test-d.ts index 26d51ba1f..bbd23891e 100644 --- a/packages/stack/__tests__/v3-matrix/matrix.test-d.ts +++ b/packages/stack/__tests__/v3-matrix/matrix.test-d.ts @@ -22,12 +22,13 @@ import { type EqlV3TypeName, V3_MATRIX } from './catalog' // One mixed-tier table spanning every capability tier + plaintext axis, built // from the catalog's own builders. const records = encryptedTable('records', { - count: V3_MATRIX['eql_v3.integer'].builder('count'), // number, storage-only - score: V3_MATRIX['eql_v3.integer_eq'].builder('score'), // number, equality - rank: V3_MATRIX['eql_v3.integer_ord'].builder('rank'), // number, order + range - createdAt: V3_MATRIX['eql_v3.timestamp_ord'].builder('created_at'), // date - email: V3_MATRIX['eql_v3.text_search'].builder('email'), // string, full-text - active: V3_MATRIX['eql_v3.boolean'].builder('active'), // boolean, storage-only + count: V3_MATRIX['public.eql_v3_integer'].builder('count'), // number, storage-only + score: V3_MATRIX['public.eql_v3_integer_eq'].builder('score'), // number, equality + rank: V3_MATRIX['public.eql_v3_integer_ord'].builder('rank'), // number, order + range + balance: V3_MATRIX['public.eql_v3_bigint_ord'].builder('balance'), // bigint, order + range + createdAt: V3_MATRIX['public.eql_v3_timestamp_ord'].builder('created_at'), // date + email: V3_MATRIX['public.eql_v3_text_search'].builder('email'), // string, full-text + active: V3_MATRIX['public.eql_v3_boolean'].builder('active'), // boolean, storage-only }) describe('eql_v3 type-driven matrix (types)', () => { @@ -36,6 +37,7 @@ describe('eql_v3 type-driven matrix (types)', () => { count: number score: number rank: number + balance: bigint createdAt: Date email: string active: boolean @@ -52,6 +54,9 @@ describe('eql_v3 type-driven matrix (types)', () => { expectTypeOf>().toEqualTypeOf< 'equality' | 'orderAndRange' >() + expectTypeOf>().toEqualTypeOf< + 'equality' | 'orderAndRange' + >() expectTypeOf>().toEqualTypeOf< 'equality' | 'orderAndRange' >() @@ -67,24 +72,24 @@ describe('eql_v3 type-driven matrix (types)', () => { type Queryable = QueryableColumnsOf // A queryable column is a member of the set... - const ok: Queryable = V3_MATRIX['eql_v3.integer_eq'].builder('score') + const ok: Queryable = V3_MATRIX['public.eql_v3_integer_eq'].builder('score') expectTypeOf(ok).toExtend() // ...but a storage-only column is not. // @ts-expect-error - storage-only integer column is excluded from QueryableColumnsOf const _notQueryable: Queryable = - V3_MATRIX['eql_v3.integer'].builder('count') + V3_MATRIX['public.eql_v3_integer'].builder('count') // @ts-expect-error - storage-only boolean column is excluded from QueryableColumnsOf const _boolNotQueryable: Queryable = - V3_MATRIX['eql_v3.boolean'].builder('active') + V3_MATRIX['public.eql_v3_boolean'].builder('active') }) it('anchors the catalog key union to the real column source of truth', () => { // `EqlV3TypeName` is derived from `AnyEncryptedV3Column`, so every real // domain name is a member — no hand-copied list. - expectTypeOf<'eql_v3.text_search'>().toExtend() - expectTypeOf<'eql_v3.boolean'>().toExtend() + expectTypeOf<'public.eql_v3_text_search'>().toExtend() + expectTypeOf<'public.eql_v3_boolean'>().toExtend() // A key outside the real domain set is rejected — this is what makes the // `Record` catalog a compile-time coverage check. diff --git a/packages/stack/__tests__/v3-matrix/matrix.test.ts b/packages/stack/__tests__/v3-matrix/matrix.test.ts index c2bdf320d..8b985fa23 100644 --- a/packages/stack/__tests__/v3-matrix/matrix.test.ts +++ b/packages/stack/__tests__/v3-matrix/matrix.test.ts @@ -33,4 +33,35 @@ describe('eql_v3 type-driven domain matrix (runtime)', () => { indexes: spec.indexes, }) }) + + it.each([ + 'public.eql_v3_text_ord_ore', + 'public.eql_v3_text_ord', + 'public.eql_v3_text_search', + ] as const)('%s uses non-empty positive samples for live Postgres inserts', (eqlType) => { + expect(V3_MATRIX[eqlType].samples[0]).not.toBe('') + }) + + // `timestamp` domains set `cast_as: 'timestamp'` (not `'date'`) precisely to + // preserve the time-of-day. The live matrix can only PROVE that preservation + // if its samples actually carry a non-zero time-of-day: a regression back to + // `'date'` truncation collapses the instant to midnight, so midnight-only + // samples (`DATE_S`) would survive truncation and pass silently. This guards + // the live suite's truncation-detection power at build time — flip the + // timestamp rows back to `DATE_S` and this fails. + it.each([ + 'public.eql_v3_timestamp', + 'public.eql_v3_timestamp_eq', + 'public.eql_v3_timestamp_ord_ore', + 'public.eql_v3_timestamp_ord', + ] as const)('%s carries a sample with a non-zero time-of-day', (eqlType) => { + const samples = V3_MATRIX[eqlType].samples as readonly Date[] + const hasTimeOfDay = (d: Date) => + d.getUTCHours() + + d.getUTCMinutes() + + d.getUTCSeconds() + + d.getUTCMilliseconds() > + 0 + expect(samples.some(hasTimeOfDay)).toBe(true) + }) }) diff --git a/packages/stack/__tests__/v3-matrix/needle-for.test.ts b/packages/stack/__tests__/v3-matrix/needle-for.test.ts new file mode 100644 index 000000000..87f68e365 --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/needle-for.test.ts @@ -0,0 +1,55 @@ +import { needleFor } from '@cipherstash/test-kit' +import { describe, expect, it } from 'vitest' +import { matchNeedleError } from '@/schema/match-defaults' +import { V3_MATRIX } from './catalog' + +const MATCH_BLOCK = { tokenizer: { kind: 'ngram', token_length: 3 } } as const + +const specWith = (samples: readonly unknown[]) => + ({ samples, indexes: { match: MATCH_BLOCK } }) as never + +describe('needleFor', () => { + // The guard counts codepoints; a UTF-16 `.length` check would wave '👍👍' + // through (4 code units, 2 codepoints) and the `contains` test would then + // fail inside the production guard, pointing at the wrong line. + it('skips an astral sample that the production guard would reject', () => { + expect(needleFor(specWith(['👍👍', 'ada@example.com']))).toBe( + 'ada@example.com', + ) + }) + + it('skips the empty sample', () => { + expect(needleFor(specWith(['', 'Ada Lovelace']))).toBe('Ada Lovelace') + }) + + it('skips non-string samples', () => { + expect(needleFor(specWith([42, null, 'Ada']))).toBe('Ada') + }) + + it('throws when no sample can be searched', () => { + expect(() => needleFor(specWith(['', 'ab', '👍👍']))).toThrow( + /no searchable sample/, + ) + }) + + it('honours a larger token_length', () => { + const spec = { + samples: ['ada', 'adam'], + indexes: { match: { tokenizer: { kind: 'ngram', token_length: 4 } } }, + } as never + expect(needleFor(spec)).toBe('adam') + }) + + // The contract that matters: whatever it picks, the guard must accept. + it('never returns a needle the guard rejects, across every match domain', () => { + const matchDomains = Object.values(V3_MATRIX).filter( + (spec) => spec.indexes.match, + ) + expect(matchDomains.length).toBeGreaterThan(0) + + for (const spec of matchDomains) { + const needle = needleFor(spec) + expect(matchNeedleError(needle, spec.indexes.match ?? {})).toBeUndefined() + } + }) +}) diff --git a/packages/stack/__tests__/wasm-inline-new-client.test.ts b/packages/stack/__tests__/wasm-inline-new-client.test.ts index c7a1e5564..4d2140fa1 100644 --- a/packages/stack/__tests__/wasm-inline-new-client.test.ts +++ b/packages/stack/__tests__/wasm-inline-new-client.test.ts @@ -33,12 +33,13 @@ vi.mock('@cipherstash/protect-ffi/wasm-inline', () => ({ })) import { newClient as wasmNewClient } from '@cipherstash/protect-ffi/wasm-inline' -import { Encryption, encryptedColumn, encryptedTable } from '../src/wasm-inline' +import { Encryption, encryptedTable, types } from '../src/wasm-inline' const CRN = 'crn:ap-southeast-2.aws:test-workspace' +// The WASM entry is EQL v3 — author with the `types` DSL re-exported from it. const users = encryptedTable('users', { - email: encryptedColumn('email'), + email: types.TextSearch('email'), }) beforeEach(() => { @@ -83,9 +84,9 @@ describe('wasm-inline Encryption → newClient (protect-ffi 0.25 single-object f }) it('passes a cast_as-normalised encryptConfig (SDK "string" → EQL "text")', async () => { - // `encryptedColumn('email')` defaults to `cast_as: 'string'`; the WASM - // client only accepts EQL-native variants, so the factory must run the - // config through `normalizeCastAs` before handing it to `newClient`. + // `types.TextSearch('email')` carries `cast_as: 'string'`; the WASM client + // only accepts EQL-native variants, so the factory must run the config + // through `normalizeCastAs` before handing it to `newClient`. await Encryption({ schemas: [users], config: { diff --git a/packages/stack/__tests__/wasm-inline-v3.test.ts b/packages/stack/__tests__/wasm-inline-v3.test.ts new file mode 100644 index 000000000..67329827f --- /dev/null +++ b/packages/stack/__tests__/wasm-inline-v3.test.ts @@ -0,0 +1,102 @@ +/** + * `@cipherstash/stack/wasm-inline` is EQL v3 only (#614). This pins the three + * things that make that true and keep working: + * + * 1. The factory always constructs the client with `eqlVersion: 3` — a + * v2-mode client cannot resolve the concrete `eql_v3_*` domains and would + * fail every encrypt. Only the gated Deno e2e exercises the real wire + * format, so this asserts the plumbing the e2e's effect depends on. + * 2. It still normalises SDK-facing `cast_as` to the EQL-native variant the + * WASM client accepts (v3 columns carry `cast_as: 'string'`, not `'text'`). + * 3. It rejects a v2 table with a clear message rather than pinning v3 wire to + * a v2 schema and failing opaquely inside the FFI. + * + * It also pins that the v3 authoring surface is re-exported from this entry, so + * an edge consumer authors v3 schemas from a single import. + */ + +import { beforeEach, describe, expect, it, vi } from 'vitest' + +vi.mock('@cipherstash/auth/wasm-inline', () => ({ + AccessKeyStrategy: { + create: vi.fn(() => ({ data: { __mock: 'access-key-strategy' } })), + }, + OidcFederationStrategy: class {}, +})) + +vi.mock('@cipherstash/protect-ffi/wasm-inline', () => ({ + newClient: vi.fn(async () => ({ __mock: 'wasm-client' })), + encrypt: vi.fn(), + decrypt: vi.fn(), + isEncrypted: vi.fn(), +})) + +import { newClient as wasmNewClient } from '@cipherstash/protect-ffi/wasm-inline' +// v2 builders come from the native schema entry — used only to prove the WASM +// factory REJECTS a v2 table. +import { + encryptedColumn, + encryptedTable as v2EncryptedTable, +} from '../src/schema' +import * as wasm from '../src/wasm-inline' +import { Encryption, encryptedTable, types } from '../src/wasm-inline' + +const config = { + workspaceCrn: 'crn:ap-southeast-2.aws:test-workspace', + accessKey: 'CSAK.test', + clientId: 'cid', + clientKey: 'ckey', +} as const + +// biome-ignore lint/suspicious/noExplicitAny: reading the recorded options object +const newClientOpts = () => vi.mocked(wasmNewClient).mock.calls[0][0] as any + +const users = encryptedTable('users', { + email: types.TextSearch('email'), +}) + +beforeEach(() => { + vi.clearAllMocks() +}) + +describe('wasm-inline is EQL v3 only (#614)', () => { + it('constructs the client with eqlVersion 3', async () => { + await Encryption({ schemas: [users], config }) + expect(newClientOpts().eqlVersion).toBe(3) + }) + + it('normalises cast_as on the v3 path (SDK "string" → EQL "text")', async () => { + await Encryption({ schemas: [users], config }) + // `types.TextSearch` carries `cast_as: 'string'`; the WASM client only + // accepts EQL-native variants, so the factory must map it to `'text'`. + expect(newClientOpts().encryptConfig.tables.users.email.cast_as).toBe( + 'text', + ) + }) + + it('rejects a v2 table with a clear error, before touching newClient', async () => { + const v2Users = v2EncryptedTable('users', { + email: encryptedColumn('email'), + }) + await expect( + // A JS caller can bypass the v3-only `schemas` type; the runtime guard + // must catch it. Cast to satisfy the compile-time type for this test. + Encryption({ + schemas: [v2Users as unknown as typeof users], + config, + }), + ).rejects.toThrow(/EQL v3 only/) + expect(vi.mocked(wasmNewClient)).not.toHaveBeenCalled() + }) + + it('re-exports the v3 authoring surface from this entry', () => { + expect(typeof wasm.encryptedTable).toBe('function') + expect(typeof wasm.types).toBe('object') + expect(typeof wasm.types.TextSearch).toBe('function') + expect(typeof wasm.buildEncryptConfig).toBe('function') + // The authored table is the v3 builder (carries the v3 `buildColumnKeyMap` + // marker) — not the v2 one. + expect(typeof users.buildColumnKeyMap).toBe('function') + expect(users.email.getEqlType()).toBe('public.eql_v3_text_search') + }) +}) diff --git a/packages/stack/__tests__/wasm-plaintext.test-d.ts b/packages/stack/__tests__/wasm-plaintext.test-d.ts new file mode 100644 index 000000000..ab487e842 --- /dev/null +++ b/packages/stack/__tests__/wasm-plaintext.test-d.ts @@ -0,0 +1,21 @@ +import { describe, expectTypeOf, it } from 'vitest' +import type { WasmPlaintext } from '@/wasm-inline' + +// `WasmPlaintext` is the plaintext type accepted by `encrypt` and returned by +// `decrypt` on the WASM entry point. It must admit `bigint` (int8 columns): +// protect-ffi 0.28's wasm build carries a native `bigint` across the boundary +// (`encode_plaintext` on encrypt, `js_sys::BigInt` on decrypt), so the SDK type +// must not narrow it out — otherwise bigint columns are unusable on WASM even +// though the runtime supports them. +describe('WasmPlaintext admits bigint', () => { + it('accepts a bigint value', () => { + expectTypeOf().toMatchTypeOf() + }) + + it('still accepts the base scalar plaintext types', () => { + expectTypeOf().toMatchTypeOf() + expectTypeOf().toMatchTypeOf() + expectTypeOf().toMatchTypeOf() + expectTypeOf().toMatchTypeOf() + }) +}) diff --git a/packages/stack/integration/identity/matrix-identity.integration.test.ts b/packages/stack/integration/identity/matrix-identity.integration.test.ts new file mode 100644 index 000000000..5009a4a74 --- /dev/null +++ b/packages/stack/integration/identity/matrix-identity.integration.test.ts @@ -0,0 +1,134 @@ +/** + * Live identity-aware coverage for the v3 typed client: a lock-context + * encrypt→decrypt round-trip through the MODEL path, the negative path (a model + * sealed under an identity must NOT decrypt without its context), plus audit + * metadata. + * + * Kept separate from `matrix-lock-context.test.ts`, which mocks + * `@cipherstash/protect-ffi` file-wide — a mock would neutralize a "live" + * assertion. No mock here: it federates a freshly-minted Clerk M2M JWT into a + * CTS token via `OidcFederationStrategy` and binds the lock context to `sub` + * (resolved by ZeroKMS from the token — here, the Clerk machine identity). + * + * Runs in CI on the Drizzle integration job — `integration/identity/**` is in + * its `CS_IT_SUITE` globs. Like every integration suite it THROWS rather than + * skips when unconfigured: `clerkJwtProvider()` requires `CLERK_MACHINE_TOKEN`. + */ +import { OidcFederationStrategy } from '@cipherstash/auth' +import { unwrapResult } from '@cipherstash/test-kit' +import { clerkJwtProvider } from '@cipherstash/test-kit/integration-clerk' +import { beforeAll, describe, expect, it } from 'vitest' +import { EncryptionV3, encryptedTable, types } from '@/encryption/v3' + +const users = encryptedTable('v3_identity_live_users', { + email: types.TextEq('email'), +}) + +const LOCK = { identityClaim: ['sub'] } + +// A genuine key-derivation denial — ZeroKMS cannot reproduce the identity-bound +// key without the context the model was sealed under — versus a transport/outage +// fault that must never be read as a denial. Mirrors the matchers the Drizzle +// lock-context suite pins to. +const KEY_DENIAL = /failed to retrieve key/i +const INFRA_FAULT = + /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|timed? ?out|network error/i + +describe('v3 typed client identity-aware operations (live)', () => { + let client: Awaited>> + + beforeAll(async () => { + const crn = process.env.CS_WORKSPACE_CRN + if (!crn) { + throw new Error('CS_WORKSPACE_CRN must be set for identity tests') + } + // `create()` returns a `Result`; unwrap to the strategy `config.authStrategy` + // expects. `clerkJwtProvider()` asserts CLERK_MACHINE_TOKEN and re-mints on + // every re-federation. + const federation = OidcFederationStrategy.create(crn, clerkJwtProvider()) + if (federation.failure) { + throw new Error(`[federation]: ${federation.failure.message}`) + } + client = await EncryptionV3({ + schemas: [users], + config: { authStrategy: federation.data }, + }) + }, 30000) + + it('round-trips a model with a lock context (encrypt + decrypt bound to identity)', async () => { + const encrypted = unwrapResult( + await client + .encryptModel({ email: 'ada@example.com' }, users) + .withLockContext(LOCK), + ) + expect(encrypted.email).toHaveProperty('c') + + // decryptModel takes the lock context as a positional 3rd arg + // (`LockContextInput` = `LockContext | { identityClaim }`). + const decrypted = unwrapResult( + await client.decryptModel(encrypted, users, LOCK), + ) + expect(decrypted.email).toBe('ada@example.com') + }, 30000) + + // NEGATIVE PATH. The round-trip above applies the SAME context on both sides, + // so it stays green even if the model path ignored the lock context entirely. + // This is the assertion that fails if it does: a model sealed under an identity + // must NOT decrypt without its context. `decryptModel` reports denial as a + // `Result.failure` rather than throwing, so read it off the result (and count + // a throw as denial too) instead of unwrapping — a bare `unwrapResult` would + // turn a held boundary into a thrown error and mask WHY it was denied. + it('a model sealed with a lock context does NOT decrypt without it', async () => { + const encrypted = unwrapResult( + await client + .encryptModel({ email: 'ada@example.com' }, users) + .withLockContext(LOCK), + ) + + let denied = false + let message = '' + try { + const result: { failure?: { message: string } } = + await client.decryptModel(encrypted, users) + denied = Boolean(result.failure) + message = result.failure?.message ?? '' + } catch (error) { + denied = true + message = (error as Error).message + } + + expect( + denied, + `model decrypt must be denied without its context (got: ${message})`, + ).toBe(true) + // A real key-derivation denial, not an outage masquerading as one. + expect(message).toMatch(KEY_DENIAL) + expect(message).not.toMatch(INFRA_FAULT) + }, 30000) +}) + +// The `.audit({ metadata })` path is identity-AGNOSTIC — it attaches audit +// metadata to an encrypt, with no lock context and no `sub` binding. It needs +// only CS credentials, so it gets its own suite with a plain (non-federated) +// client. Coupling it to the Clerk federation `beforeAll` above would fail this +// test on a Clerk outage or a rotated `CLERK_MACHINE_TOKEN` — for behaviour it +// never exercises. +describe('v3 typed client audit metadata (live)', () => { + let client: Awaited>> + + beforeAll(async () => { + client = await EncryptionV3({ schemas: [users] }) + }, 30000) + + it('accepts .audit({ metadata }) on the encrypt path and still round-trips', async () => { + const encrypted = unwrapResult( + await client + .encrypt('secret@example.com', { table: users, column: users.email }) + .audit({ metadata: { sub: 'toby@cipherstash.com', type: 'encrypt' } }), + ) + expect(encrypted).toHaveProperty('c') + + const decrypted = unwrapResult(await client.decrypt(encrypted)) + expect(decrypted).toBe('secret@example.com') + }, 30000) +}) diff --git a/packages/stack/integration/shared/harness.integration.test.ts b/packages/stack/integration/shared/harness.integration.test.ts new file mode 100644 index 000000000..ba92ee617 --- /dev/null +++ b/packages/stack/integration/shared/harness.integration.test.ts @@ -0,0 +1,125 @@ +import { releaseManifest } from '@cipherstash/eql/sql' +import { databaseUrl, dbVariant, pgrestUrl } from '@cipherstash/test-kit' +import postgres from 'postgres' +import { afterAll, expect, it } from 'vitest' + +/** + * Proves the harness itself, so a failure in the adapter suites is never + * ambiguous between "the adapter is broken" and "the database was never set up". + * + * `globalSetup` has already run `stash eql install --eql-version 3` against the + * configured database by the time this file executes. Nothing here is skippable: + * an unconfigured run throws in `globalSetup`, before any test is collected. + */ +const sql = postgres(databaseUrl(), { prepare: false }) + +afterAll(async () => { + await sql.end() +}) + +it('installed the pinned EQL v3 release through the real CLI', async () => { + const [row] = await sql< + { version: string }[] + >`SELECT eql_v3.version() AS version` + + expect(row?.version).toBe(releaseManifest.eqlVersion) +}) + +it('installed the concrete public.eql_v3_* domains', async () => { + const [row] = await sql<{ count: string }[]>` + SELECT count(*)::text AS count + FROM pg_type t + JOIN pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = 'public' AND t.typname LIKE 'eql_v3\\_%' + ` + + // The SDK models 41 of them; the bundle ships more (json, jsonb_entry, the + // `*_ord_ope` twins). Assert the floor, not the exact count, so a bundle that + // adds a domain does not fail a test that is really about "the install ran". + expect(Number(row?.count)).toBeGreaterThanOrEqual(41) +}) + +/** + * The ORE opclass is superuser-only. This is the observable difference between + * the two database variants, and the reason the nine `_ord_ore` domains are + * `deferred` in the catalog: on managed Postgres their columns exist and compare + * correctly, but `ORDER BY eql_v3.ord_term_ore(col)` silently falls back to raw + * bytea order. Pinning it here means a bundle change that alters the privilege + * story shows up as a harness failure rather than as a mysterious ordering bug. + */ +it('installs the ORE opclass only when the connecting role is a superuser', async () => { + const [role] = await sql<{ is_super: boolean }[]>` + SELECT rolsuper AS is_super FROM pg_roles WHERE rolname = current_user + ` + const [opclass] = await sql<{ count: string }[]>` + SELECT count(*)::text AS count + FROM pg_opclass o + JOIN pg_namespace n ON n.oid = o.opcnamespace + WHERE n.nspname LIKE 'eql_v3%' + ` + + const opclasses = Number(opclass?.count) + if (role?.is_super) { + expect(opclasses).toBeGreaterThan(0) + } else { + expect(opclasses).toBe(0) + } +}) + +/** + * Both database variants are asserted, neither is skipped. + * + * A skipped test reads exactly like a passing one, and the two skips that used to + * live here hid a real bug: `dbVariant()` inferred `postgres` for the Drizzle job + * running against `supabase/postgres`, so EQL installed without `--supabase`, the + * grants were never applied, and the grants test quietly did not run. + * + * So assert the whole truth: on a Supabase database the roles exist and hold the + * grants; on a plain one they do not exist at all. + */ +it('applies the anon grants on Supabase, and has no such roles on plain Postgres', async () => { + const [roles] = await sql<{ count: string }[]>` + SELECT count(*)::text AS count FROM pg_roles + WHERE rolname IN ('anon', 'authenticated', 'service_role') + ` + + if (dbVariant() === 'supabase') { + expect(Number(roles?.count)).toBe(3) + + // `eql_v3_internal` is load-bearing: the SECURITY INVOKER extractors resolve + // it with the CALLER's privileges, so without this grant every encrypted + // filter fails for `anon` with "permission denied for schema". + const [privs] = await sql<{ eql_v3: boolean; internal: boolean }[]>` + SELECT has_schema_privilege('anon', 'eql_v3', 'USAGE') AS eql_v3, + has_schema_privilege('anon', 'eql_v3_internal', 'USAGE') AS internal + ` + expect(privs).toEqual({ eql_v3: true, internal: true }) + return + } + + // Plain Postgres: the Supabase roles do not exist, so there is nothing to + // grant. Asserting their ABSENCE is what makes the variant claim falsifiable — + // if this database ever grew them, the `--supabase` install path would have to + // run here too. + expect(Number(roles?.count)).toBe(0) +}) + +/** + * PostgREST is asserted on its own axis, not on the variant. The Drizzle job runs + * against the Supabase database and does not need PostgREST; conflating "is this + * Supabase" with "is PostgREST up" is precisely what made `dbVariant()` lie. + */ +it('serves PostgREST when configured, and is not configured otherwise', async () => { + const url = process.env['PGRST_URL'] + + if (!url) { + // Only the plain-Postgres compose file omits PostgREST. A Supabase database + // with no `PGRST_URL` means the job forgot to pass it. + expect(dbVariant()).toBe('postgres') + return + } + + const response = await fetch(`${pgrestUrl()}/`) + + expect(response.status).toBe(200) +}) diff --git a/packages/stack/integration/shared/json-crypto.integration.test.ts b/packages/stack/integration/shared/json-crypto.integration.test.ts new file mode 100644 index 000000000..77382a72a --- /dev/null +++ b/packages/stack/integration/shared/json-crypto.integration.test.ts @@ -0,0 +1,87 @@ +/** + * Live round-trip for the v3 `types.Json()` column — an encrypted JSONB document + * (`public.eql_v3_json`). Proves the new json column model encrypts and decrypts + * a real document through protect-ffi (no DB query here; containment is exercised + * by the Drizzle json suite). The stored payload is protect-ffi's + * `SteVecDocument`, carrying an `sv` array rather than a scalar `c` ciphertext. + */ +import { unwrapResult } from '@cipherstash/test-kit' +import { beforeAll, describe, expect, it } from 'vitest' +import { EncryptionV3, encryptedTable, types } from '@/encryption/v3' + +const docs = encryptedTable('v3_json_docs', { + profile: types.Json('profile'), +}) + +describe('v3 typed client — encrypted JSONB round-trip', () => { + let client: Awaited>> + + beforeAll(async () => { + client = await EncryptionV3({ schemas: [docs] }) + }, 30000) + + it('round-trips a JSON document through encrypt/decrypt', async () => { + const value = { + user: 'ada@example.com', + roles: ['admin', 'eng'], + active: true, + meta: { since: 2020 }, + } + + const encrypted = unwrapResult( + await client.encrypt(value, { table: docs, column: docs.profile }), + ) + // An encrypted JSONB document carries an `sv` array, not a scalar `c` + // ciphertext (the stored shape is protect-ffi's `SteVecDocument`). + expect(Array.isArray((encrypted as { sv?: unknown }).sv)).toBe(true) + + const decrypted = unwrapResult(await client.decrypt(encrypted)) + expect(decrypted).toEqual(value) + }, 30000) + + it('round-trips a JSON document through the model path', async () => { + const model = { profile: { user: 'grace@example.com', roles: ['eng'] } } + const encrypted = unwrapResult(await client.encryptModel(model, docs)) + const decrypted = unwrapResult(await client.decryptModel(encrypted, docs)) + expect(decrypted).toEqual(model) + }, 30000) + + // A JSON document is not only an object: `types.Json` (and the `JsonDocument` + // plaintext type) also admit a top-level array and `null`. Pin both so a + // regression in encrypted-JSONB encoding of non-object roots turns a test red. + it.each([ + ['array root', [1, 'two', { three: 3 }]], + ['null root', null], + ] as const)( + 'round-trips a %s', + async (_label, value) => { + const encrypted = unwrapResult( + await client.encrypt(value, { table: docs, column: docs.profile }), + ) + const decrypted = unwrapResult(await client.decrypt(encrypted)) + expect(decrypted).toEqual(value) + }, + 30000, + ) + + // The boundary the `JsonDocument` type encodes: a top-level SCALAR is not a + // JSON document. protect-ffi rejects it ("Cannot convert … to Json") — a bare + // scalar belongs in a scalar domain (`types.TextEq`, `types.IntegerEq`, …). + // `as never` bypasses the compile-time block to prove the runtime enforces it. + it.each([ + ['string', 'hello'], + ['number', 42], + ['boolean', true], + ] as const)( + 'rejects a top-level %s scalar at encrypt', + async (_label, scalar) => { + const result = await client.encrypt(scalar as never, { + table: docs, + column: docs.profile, + }) + expect(result.failure).toBeDefined() + expect(result.failure?.message).toMatch(/convert .* to Json/i) + }, + 30000, + ) +}) diff --git a/packages/stack/integration/shared/match-bloom.integration.test.ts b/packages/stack/integration/shared/match-bloom.integration.test.ts new file mode 100644 index 000000000..563b3cec6 --- /dev/null +++ b/packages/stack/integration/shared/match-bloom.integration.test.ts @@ -0,0 +1,117 @@ +import { expect, it } from 'vitest' +import { EncryptionV3 } from '@/encryption/v3' +import { encryptedTable, types } from '@/eql/v3' + +/** + * The invariant `contains()` rests on, asserted directly on the wire rather than + * inferred from a query result. + * + * `eql_v3.contains(a, b)` is `match_term(a) @> match_term(b)`: bloom-filter + * (`smallint[]`) containment. So a substring search can only work if + * + * bloom(needle) ⊆ bloom(haystack) + * + * The match index tokenizes into downcased 3-grams. With `include_original: true` + * the WHOLE value is bloomed as an extra token. That is right for STORAGE and + * wrong for a QUERY operand: a whole-needle token is, by definition, not a + * trigram of the haystack, so the subset relation breaks and every strict + * substring search returns zero rows — silently. + * + * Both v3 adapters build match operands with `encrypt` (the full storage + * envelope), not `encryptQuery`, because PostgREST cannot cast a filter value to + * `eql_v3.query_*`. They are therefore structurally exposed. Today it is masked: + * protect-ffi ignores `include_original` altogether, so neither side carries the + * whole-value token and two bugs cancel out. See cipherstash/stack#615. + * + * WHEN protect-ffi STARTS HONOURING `include_original`, this file goes red — and + * that is the intent. The subset assertion below is the precondition; the query + * tests in the text family are the symptom. Fixing it means the operand must + * stop carrying the original token (via `encryptQuery`, or by disabling the flag + * on the query path) — not relaxing this test. + */ +const docs = encryptedTable('match_bloom_probe', { + bio: types.TextMatch('bio'), +}) + +const HAYSTACK = 'ada@example.com' + +async function bloomOf( + client: Awaited>, + value: string, +) { + const result = await client.encrypt(value, { column: docs.bio, table: docs }) + if (result.failure) throw new Error(result.failure.message) + const envelope = result.data as { bf?: number[] } + if (!Array.isArray(envelope.bf)) { + throw new Error( + `Expected a bloom filter (bf) on the envelope for "${value}"`, + ) + } + return new Set(envelope.bf) +} + +const isSubset = (needle: Set, haystack: Set) => + [...needle].every((bit) => haystack.has(bit)) + +it.each([ + // Degenerate: the whole needle IS a trigram, so it holds under either + // behaviour. Passing this proves nothing about `include_original`. + { label: '3-character needle (one trigram)', needle: 'ada' }, + // The discriminating cases: strict substrings longer than one trigram. These + // are what break the moment a whole-needle token enters the operand. + { label: 'interior substring, 7 chars', needle: 'a@examp' }, + { label: 'trailing substring, 4 chars', needle: '.com' }, + { label: 'the whole value', needle: HAYSTACK }, +])('bloom(needle) is a subset of bloom(haystack) for a $label', async ({ + needle, +}) => { + const client = await EncryptionV3({ schemas: [docs] }) + const haystack = await bloomOf(client, HAYSTACK) + const probe = await bloomOf(client, needle) + + expect(HAYSTACK.includes(needle)).toBe(true) + expect( + isSubset(probe, haystack), + `bloom("${needle}") is not contained in bloom("${HAYSTACK}"). ` + + 'The operand carries a token the haystack lacks — most likely the ' + + '`include_original` whole-value token. See the file header.', + ).toBe(true) +}, 120_000) + +it('a needle absent from the haystack is NOT a bloom subset', async () => { + // Without this, an implementation that blooms every needle to the empty set + // would satisfy every assertion above. + const client = await EncryptionV3({ schemas: [docs] }) + const haystack = await bloomOf(client, HAYSTACK) + const probe = await bloomOf(client, 'qqqzzz') + + expect(isSubset(probe, haystack)).toBe(false) +}, 120_000) + +it('a needle blooms to a non-empty filter', async () => { + const client = await EncryptionV3({ schemas: [docs] }) + expect((await bloomOf(client, 'ada')).size).toBeGreaterThan(0) +}, 120_000) + +/** + * The subset assertions above are only worth having if they can FAIL. A whole- + * value `include_original` token is, from the bloom's point of view, just a + * token the haystack does not have — so simulate one by unioning in the bits of + * a value the haystack never saw, and confirm the subset relation collapses. + * + * This is a test of the test. It is the reason the substring cases can be + * trusted to catch `include_original` leaking into the query operand, rather + * than passing for some unrelated reason. + */ +it('the subset assertion detects a single foreign token in the operand', async () => { + const client = await EncryptionV3({ schemas: [docs] }) + const haystack = await bloomOf(client, HAYSTACK) + const substring = await bloomOf(client, 'a@examp') + const foreign = await bloomOf(client, 'qqqzzz') + + // The honest operand is contained... + expect(isSubset(substring, haystack)).toBe(true) + // ...and one extra token is enough to break it. + const polluted = new Set([...substring, ...foreign]) + expect(isSubset(polluted, haystack)).toBe(false) +}, 120_000) diff --git a/packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts b/packages/stack/integration/shared/matrix-bulk.integration.test.ts similarity index 88% rename from packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts rename to packages/stack/integration/shared/matrix-bulk.integration.test.ts index 61915f15e..0ef71beea 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts +++ b/packages/stack/integration/shared/matrix-bulk.integration.test.ts @@ -5,18 +5,16 @@ * `bulkDecryptModels` against real FFI, exercising v3 model reconstruction at * scale. Live soft-skip. */ -import 'dotenv/config' +import { unwrapResult } from '@cipherstash/test-kit' import { beforeAll, describe, expect, it } from 'vitest' import { EncryptionV3, encryptedTable, types } from '@/encryption/v3' -import { unwrapResult } from '../fixtures' -import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' const people = encryptedTable('v3_bulk_people', { nickname: types.TextEq('nickname'), age: types.IntegerOrd('age'), }) -describeLive('v3 typed client bulk-at-scale (live)', () => { +describe('v3 typed client bulk-at-scale (live)', () => { let client: Awaited>> beforeAll(async () => { diff --git a/packages/stack/__tests__/v3-matrix/matrix-live.test.ts b/packages/stack/integration/shared/matrix-crypto.integration.test.ts similarity index 79% rename from packages/stack/__tests__/v3-matrix/matrix-live.test.ts rename to packages/stack/integration/shared/matrix-crypto.integration.test.ts index ff51f02f7..11dcd4432 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-live.test.ts +++ b/packages/stack/integration/shared/matrix-crypto.integration.test.ts @@ -2,9 +2,9 @@ * Live round-trip half of the type-driven v3 matrix — closes the "live cliff". * * The structural `matrix.test.ts` proves builder/eqlType/capabilities/`build()` - * wiring for all 35 domains WITHOUT ever touching real FFI ciphertext. This file + * wiring for all 39 domains WITHOUT ever touching real FFI ciphertext. This file * completes the picture: every domain × every catalog `sample` is encrypted and - * decrypted through a live CipherStash client, so all 35 domains gain live + * decrypted through a live CipherStash client, so all 39 domains gain live * behavioral proof (the Rust harness's whole premise) — not just 7. * * Round-trips go through the MODEL path (`encryptModel`/`decryptModel`) so @@ -17,27 +17,23 @@ * samples (NaN/±Infinity) use the single-value path — the guard throws * client-side before any network — and so stay cheap even one at a time. */ -import 'dotenv/config' -import { beforeAll, describe, expect, it } from 'vitest' -import { EncryptionV3, encryptedTable } from '@/encryption/v3' -import { unwrapResult } from '../fixtures' -import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' import { type DomainSpec, type EqlV3TypeName, + eqlTypeSlug as slug, typedEntries, + unwrapResult, V3_MATRIX, -} from './catalog' - -/** `eql_v3.integer_ord` → `integer_ord`: a valid, per-domain-unique column name. */ -const slug = (t: EqlV3TypeName): string => t.replace('eql_v3.', '') +} from '@cipherstash/test-kit' +import { beforeAll, describe, expect, it } from 'vitest' +import { EncryptionV3, encryptedTable } from '@/encryption/v3' // `as const satisfies Record<...>` gives `V3_MATRIX` a narrower type than // `Record` (rows that omit the optional // `errorSamples` field literally lack that key, rather than typing it // `undefined`). Explicit type arguments pin `typedEntries`'s inferred `V` back // to the declared `DomainSpec` shape — without them, `spec` below is inferred -// as the union of all 35 distinct row literals, and `.errorSamples` fails to +// as the union of all 39 distinct row literals, and `.errorSamples` fails to // resolve on members that omit the key (`tsc` catches this; `vitest run` // alone would not, since it only transpiles `.test.ts` files, never // typechecks them). @@ -73,7 +69,7 @@ const errorCases = domains.flatMap(([t, spec]) => ), ) -describeLive('v3 matrix live round-trip (all domains × samples)', () => { +describe('v3 matrix live round-trip (all domains × samples)', () => { let client: Awaited> let encrypted: Array> let decrypted: Array> @@ -91,9 +87,17 @@ describeLive('v3 matrix live round-trip (all domains × samples)', () => { it.each( roundTripCases, )('%s round-trips through the model path', (_label, col, sample, i) => { - // Guard against a false pass: the field must be a real ciphertext (`c`), - // not a plaintext value that slipped through un-encrypted. - expect(encrypted[i][col]).toHaveProperty('c') + // Guard against a false pass: the field must be a real ciphertext, not a + // plaintext value that slipped through un-encrypted. Scalar domains carry it + // at a top-level `c`; a JSON (`eql_v3_json`) document is an ste_vec payload + // (`{ k: 'sv', sv: [...] }`) with NO top-level `c`, so it is guarded by the + // presence of its `sv` array instead. + const payload = encrypted[i][col] as { k?: unknown; sv?: unknown } + if (payload?.k === 'sv') { + expect(Array.isArray(payload.sv)).toBe(true) + } else { + expect(payload).toHaveProperty('c') + } const actual = decrypted[i][col] if (sample instanceof Date) { @@ -104,9 +108,10 @@ describeLive('v3 matrix live round-trip (all domains × samples)', () => { } }) - // Mirrors number-protect.test.ts: NaN/±Infinity must be rejected. The guard - // (encrypt.ts) throws client-side, so the single-value path is the honest place - // to prove where the rejection fires. + // Mirrors number-protect.test.ts: NaN/±Infinity (number domains) and + // out-of-range i64 values (bigint domains) must be rejected. The guard + // (assertValidNumericValue) throws client-side, so the single-value path is + // the honest place to prove where the rejection fires. it.each(errorCases)('%s is rejected at encrypt', async (_label, col, bad) => { const column = (table as unknown as Record)[col] const result = await client.encrypt(bad as never, { diff --git a/packages/stack/__tests__/v3-matrix/matrix-keyset.test.ts b/packages/stack/integration/shared/matrix-keyset.integration.test.ts similarity index 88% rename from packages/stack/__tests__/v3-matrix/matrix-keyset.test.ts rename to packages/stack/integration/shared/matrix-keyset.integration.test.ts index cd6c2a77d..d1bba4ff8 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-keyset.test.ts +++ b/packages/stack/integration/shared/matrix-keyset.integration.test.ts @@ -3,12 +3,11 @@ * The invalid-UUID case is deterministic — validation happens before any network * — so it runs in CI without credentials; the round-trip case is live soft-skip. */ -import 'dotenv/config' + import { ensureKeyset } from '@cipherstash/protect-ffi' +import { unwrapResult } from '@cipherstash/test-kit' import { beforeAll, describe, expect, it } from 'vitest' import { EncryptionV3, encryptedTable, types } from '@/encryption/v3' -import { unwrapResult } from '../fixtures' -import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' const users = encryptedTable('v3_keyset_users', { email: types.TextEq('email'), @@ -27,7 +26,7 @@ describe('EncryptionV3 keyset config (deterministic)', () => { }) }) -describeLive('EncryptionV3 keyset config (live)', () => { +describe('EncryptionV3 keyset config (live)', () => { let keysetId: string beforeAll(async () => { diff --git a/packages/stack/integration/shared/matrix-sql.integration.test.ts b/packages/stack/integration/shared/matrix-sql.integration.test.ts new file mode 100644 index 000000000..f17c836d0 --- /dev/null +++ b/packages/stack/integration/shared/matrix-sql.integration.test.ts @@ -0,0 +1,619 @@ +/** + * Live Postgres coverage for ALL 35 v3 domains — one query-correctness proof + * per domain, dispatched by capability tier, against a real installed eql_v3 + * extension. + * + * `matrix-live.test.ts` proves every domain round-trips through live FFI + * ciphertext, but never touches SQL. `schema-v3-pg.test.ts` proves real SQL + * query behaviour, but only for 4 hand-picked domains. Neither is redundant + * with this file: the equality-via-ORE fix (`infer-index-type.ts`) shows an + * SDK-side bug can hide behind a clean FFI round-trip and only surface + * against real Postgres — defence in depth means every domain gets that + * proof, not just a representative few. This file also doubles as one + * canonical, runnable example per capability tier of how to actually query + * each kind of v3 domain in SQL — useful reference for engineers and agents + * writing new domain-consuming code. + * + * ONE mega table (every covered domain, one column each — ORE domains excluded, + * see the `domains` filter below), + * two seeded rows (`samples[0]` / `samples[1]` from the catalog — every domain + * has at least two), and per domain one proof per query permutation its indexes + * support — proving each selects the expected row and not the other. Beyond the + * per-capability proofs below, every applicable domain also exercises the public + * two-arg negation/containment/range functions: `eql_v3.neq` (eq domains), + * `eql_v3.contained_by` (match domains), and explicit two-bound `eql_v3.gte`+`lte` + * with strict `gt`+`lt` (ordering domains), plus a strict pairwise-`lt` ordering + * proof. Queries use a FULL encrypted + * operand (`client.encrypt`, same payload as storage) compared against the + * column with a public two-arg `eql_v3.*(col, operand::jsonb)` function. (The + * operand carries every index term, so the SQL function per proof, not a + * `queryType`, selects which term is compared. protect-ffi 0.29 also mints + * term-only `eql_v3.query_` operands via `encryptQuery`; the + * full-envelope path stays because it is what the integrations send.) + * Dispatch mirrors the priority `resolveIndexType` uses (match > unique > ore): + * - match (text_match, text_search): `eql_v3.contains(col, operand)` + * - eq (any `unique` domain): `eql_v3.eq(col, operand)` + * - ord (any `ore` domain): ORE range `eql_v3.gte(col,op) AND + * eql_v3.lte(col,op)`. Pure-ORE numeric/date `*_ord`/`*_ord_ore` domains + * have no `hm` term, so `eql_v3.eq` there resolves to `ord_term` — that IS + * the equality-via-ORE proof — while text order domains carry BOTH `hm` and + * `ob`, so they use the explicit range to exercise `ob` (a bare `eql_v3.eq` + * would silently compare `hm`). Text order domains also run the eq proof. + * - storage (no index): no query is possible; proves the ciphertext, cast to + * THIS SPECIFIC Postgres domain type, survives a real INSERT/SELECT and + * still decrypts — the one thing the FFI-only round-trip can't show. + * + * In addition, EVERY ORE ordering domain (every `ore`-indexed domain: all + * `_ord`/`_ord_ore` numeric/date/timestamp domains plus `text_ord`, + * `text_ord_ore` and `text_search`) gets a STRICT total-order proof. Its + * distinct sample values are each seeded as their own row (under a separate + * `ORDER_RUN_ID`, so the two-row proofs above are unaffected) and the boolean + * `eql_v3.lt` comparison is used — via a self cross-join ranking — to prove the + * ORE order reproduces the full plaintext order (a { + if (expected instanceof Date) { + expect(typeof decrypted).toBe('string') + expect(new Date(decrypted)).toEqual(expected) + return + } + + expect(decrypted).toBe(expected) +} + +// Covered domains only. The nine `_ord_ore` (block-ORE) domains are `deferred`: +// their columns cannot hold data on non-superuser Postgres (the domain CHECK +// raises `ore_domain_unavailable`), so a mega-table built from every row would +// fail to seed on the `supabase/postgres` variant this suite also runs against. +// ORE SQL-operator coverage is a superuser-only follow-up, matching the split +// `relational.integration.test.ts` already makes. +const domains = typedEntries(V3_MATRIX).filter(([, spec]) => isCovered(spec)) + +const columns = Object.fromEntries( + domains.map(([t, spec]) => [slug(t), spec.builder(slug(t))]), +) +const table = encryptedTable(TABLE_NAME, columns as never) + +/** + * Which proofs a domain's configured indexes call for. Unlike a single-kind + * classifier these lists are NOT mutually exclusive — a domain runs EVERY proof + * its indexes support: + * + * - eq (`hm`): every domain carrying a `unique` index → `eq_term`/`hmac_256`. + * - ord: every domain carrying an ordering index — `ore` (`ob` term) or `ope` + * (`op` term, the eql-3.0.0 flavour of the plain `_ord` domains) → + * `ord_term`. + * - match (`bf`): every domain carrying a `match` index → `match_term`/`bloom_filter`. + * - storage: a domain with NO index — only the ciphertext round-trip proof. + * + * Text order domains (`text_ord`/`text_ord_ore`) carry BOTH `unique` and an + * ordering index, so they appear in `eqDomains` AND `ordDomains` and run both + * proofs — a wrong-valued ordering term would otherwise slip through an + * eq-only check (text equality is HMAC-based, so `queryType:'equality'` on + * them resolves to `hm`, never the ordering term; their ord term is built with + * `queryType:'orderAndRange'` below). `text_search` also carries all three + * indexes but is deliberately exercised by the match proof ALONE — its + * distinguishing, richest capability and the one canonical example per tier — + * so it is excluded from the eq/ord lists via `!match`. + */ +const hasIndex = ( + indexes: DomainSpec['indexes'], + key: 'unique' | 'ore' | 'ope' | 'match', +): boolean => Boolean(indexes?.[key]) + +/** Either ordering flavour — `ore` (`ob`) or `ope` (`op`). */ +const hasOrdering = (indexes: DomainSpec['indexes']): boolean => + hasIndex(indexes, 'ore') || hasIndex(indexes, 'ope') + +const matchDomains = domains.filter(([, spec]) => + hasIndex(spec.indexes, 'match'), +) +const eqDomains = domains.filter( + ([, spec]) => + hasIndex(spec.indexes, 'unique') && !hasIndex(spec.indexes, 'match'), +) +const ordDomains = domains.filter( + ([, spec]) => hasOrdering(spec.indexes) && !hasIndex(spec.indexes, 'match'), +) +const storageDomains = domains.filter( + ([, spec]) => + !hasIndex(spec.indexes, 'unique') && + !hasOrdering(spec.indexes) && + !hasIndex(spec.indexes, 'match'), +) +// The block-ORE text domains: their `ob` term is an ARRAY the FFI leaves +// empty for '' — the domain CHECK rejects it. The OPE-backed text domains +// (`text_ord`, `text_search`) emit a scalar `op` term even for '', so the +// same insert is accepted there (proven below). +const textOreDomains = domains.filter( + ([t]) => t === 'public.eql_v3_text_ord_ore', +) +const textOpeDomains = domains.filter( + ([t]) => t === 'public.eql_v3_text_ord' || t === 'public.eql_v3_text_search', +) + +// EVERY ordering domain: all `_ord`/`_ord_ore` numeric/date/timestamp +// domains PLUS the three text order domains (`text_ord`, `text_ord_ore`, +// `text_search`) — i.e. every domain carrying an ordering index (`ore` or +// `ope`). `text_search` is intentionally INCLUDED here (unlike `ordDomains`, +// which excludes it so its canonical proof stays the match one): strict +// ordering is a real capability of that domain and gets its own proof below. +const orderingDomains = domains.filter(([, spec]) => hasOrdering(spec.indexes)) + +// The number of separate ordering rows to seed: the widest ordering domain's +// distinct sample count (numeric domains carry 4; text carries 3; date/ +// timestamp carry 2). Narrower domains reuse their last sample in the extra +// rows (harmless — each per-domain proof only reads its own first N rows). +const MAX_ORDER_ROWS = Math.max( + ...orderingDomains.map(([, spec]) => spec.samples.length), +) + +/** Plaintext ordering used to derive the EXPECTED ORE order per domain. + * Dates compare by instant, numbers and bigints numerically, strings by code + * point (ORE text order is byte order, which matches JS `<` for the ASCII + * samples here). */ +const comparePlaintext = (a: unknown, b: unknown): number => { + if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime() + if (typeof a === 'number' && typeof b === 'number') return a - b + // `bigint` samples (BIGINT_S) must compare numerically, not lexicographically: + // String(-42n) < String(-9223372036854775808n) is TRUE ('-4' < '-9') yet + // -42 > -9.2e18. Without this branch the two bigint ORE domains fall through + // to the string compare below and the expected order is numerically wrong, + // even though the ORE ciphertext order is correct. (`a - b` is a bigint, so + // it can't be returned to Array.sort — use the comparison form.) + if (typeof a === 'bigint' && typeof b === 'bigint') + return a < b ? -1 : a > b ? 1 : 0 + const sa = String(a) + const sb = String(b) + return sa < sb ? -1 : sa > sb ? 1 : 0 +} + +type Row = { id: number } + +let client: Awaited> +let idA: number +let idB: number +// Separate run id for the multi-row ordering rows. Kept DISTINCT from +// TEST_RUN_ID so the existing eq/match/storage/ord proofs (which filter on +// TEST_RUN_ID and expect exactly the two idA/idB rows) never see these extra +// rows — e.g. the `text_match` "contains ada" proof would otherwise also match +// a downcased 'Ada Lovelace' row. +const ORDER_RUN_ID = `${TEST_RUN_ID}-order` +// Row ids of the seeded ordering rows, in sample-index order: orderIds[i] +// holds `samples[min(i, L-1)]` for every domain, so orderIds[0..L-1] map 1:1 +// to a domain's distinct samples[0..L-1]. +let orderIds: number[] = [] +// Query terms, pre-encrypted once in `beforeAll` (not per `it.each` case). +const eqTerms: Record = {} +const ordTerms: Record = {} +const matchTerms: Record = {} +// Full operand for each match domain's `samples[0]` value (NOT the 'ada' +// substring in `matchTerms`) — used by the `contained_by` proof. +const containedByTerms: Record = {} +// Full operand for each ordering domain's distinct samples[0..L-1], reused from +// the already-encrypted `ORDER_RUN_ID` rows (no extra encryption) — used by the +// two-bound range / strict gt-lt proof. +const orderOperands: Record = {} + +beforeAll(async () => { + // EQL v3 is installed once per run by `global-setup.ts`. + client = await EncryptionV3({ schemas: [table] as never }) + + const columnDefs = domains + .map(([t]) => `"${slug(t)}" ${t} NOT NULL`) + .join(',\n ') + + // DROP first: the table is created with IF NOT EXISTS and cleaned up by row + // DELETE only, so a table left by an earlier local run keeps its OLD column + // domain types across the `eql_v3.* -> public.*` / `timestamptz -> timestamp` + // renames — silently testing against a stale schema. Harmless in CI (fresh + // Postgres each run); load-bearing for reliable local reruns. + await sql.unsafe(`DROP TABLE IF EXISTS ${TABLE_NAME}`) + await sql.unsafe(` + CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + test_run_id TEXT NOT NULL, + ${columnDefs} + ) + `) + + // Model rows for the ordering proofs: row i carries `samples[min(i, L-1)]` + // for every domain (`L` = that domain's sample count). Rows 0/1 double as the + // classic two-row seed (samples[0]/samples[1]) reused by the existing proofs; + // rows 2..MAX_ORDER_ROWS-1 give the extra distinct values numeric/text + // ordering domains need for a full a { + const row: Record = {} + for (const [t, spec] of domains) { + row[slug(t)] = spec.samples[Math.min(i, spec.samples.length - 1)] + } + return row + }) + + const encModels = unwrapResult( + await client.bulkEncryptModels(models as never, table as never), + ) as Array> + + const colNames = domains.map(([t]) => `"${slug(t)}"`) + const insertRow = async ( + enc: Record, + runId: string, + ): Promise => { + const casts = domains.map(([t], i) => `$${i + 2}::${t}`) + // `sql.json(...)` (not the bare ciphertext object): postgres.js only infers + // an explicit wire type for `Parameter`/`Date`/`Uint8Array`/boolean/bigint — + // a plain object falls through to `'' + x` (`Bind()` in + // postgres/src/connection.js), i.e. the literal string `"[object Object]"`, + // which Postgres rejects as invalid JSON before the domain cast ever runs. + const values = domains.map(([t]) => sql.json(enc[slug(t)] as never)) + const [row] = await sql.unsafe( + `INSERT INTO ${TABLE_NAME} (test_run_id, ${colNames.join(', ')}) + VALUES ($1, ${casts.join(', ')}) + RETURNING id`, + [runId, ...values], + ) + return row.id + } + idA = await insertRow(encModels[0], TEST_RUN_ID) + idB = await insertRow(encModels[1], TEST_RUN_ID) + orderIds = [] + for (const enc of encModels) { + orderIds.push(await insertRow(enc, ORDER_RUN_ID)) + } + + const columnRef = (t: EqlV3TypeName) => + (table as unknown as Record)[slug(t)] as never + + // Query operands are FULL encrypted payloads — the same thing `client.encrypt` + // produces for storage — compared with the public two-arg + // `eql_v3.*(col, operand::jsonb)` functions in SQL. + // The full operand carries every index term, so `queryType` dispatch is gone — + // the SQL function chosen per proof (eq / gte+lte / contains) selects which + // term the comparison uses. `opts` is cast `as never` because these columns + // are built dynamically (`Object.fromEntries`) and carry no static type. + const encryptOperand = async (t: EqlV3TypeName, value: unknown) => + unwrapResult( + await client.encrypt( + value as never, + { + table, + column: columnRef(t), + } as never, + ), + ) + for (const [t, spec] of eqDomains) { + eqTerms[slug(t)] = await encryptOperand(t, spec.samples[0]) + } + for (const [t, spec] of ordDomains) { + ordTerms[slug(t)] = await encryptOperand(t, spec.samples[0]) + } + // text_match/text_search: query the substring "ada", present only in the + // seeded sample of exactly one row per domain. + for (const [t] of matchDomains) { + matchTerms[slug(t)] = await encryptOperand(t, 'ada') + } + // `contained_by` operand = the FULL `samples[0]` value (row idA). Its token + // set equals idA's, so idA is contained_by it, while idB (`samples[1]`) has + // tokens the operand lacks. Reuse the already-encrypted `encModels[0]`. + for (const [t] of matchDomains) { + containedByTerms[slug(t)] = encModels[0][slug(t)] + } + // Range-bound operands: the full operand for each distinct sample of an + // ordering domain, taken straight from the encrypted `ORDER_RUN_ID` rows + // (`encModels[i]` ↔ `orderIds[i]` ↔ `samples[i]`). No extra encryption. + for (const [t, spec] of orderingDomains) { + orderOperands[slug(t)] = encModels + .slice(0, spec.samples.length) + .map((m) => m[slug(t)]) + } +}, 120000) + +afterAll(async () => { + await sql.unsafe(`DELETE FROM ${TABLE_NAME} WHERE test_run_id = ANY($1)`, [ + [TEST_RUN_ID, ORDER_RUN_ID], + ]) + await sql.end() +}, 30000) + +describe('v3 matrix live Postgres coverage (all covered domains)', () => { + it.each( + eqDomains, + )('%s: eql_v3.eq(col, operand) selects the exact row', async (eqlType) => { + const col = slug(eqlType) + const rows = await sql.unsafe( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND eql_v3.eq("${col}", $2::jsonb)`, + [TEST_RUN_ID, sql.json(eqTerms[col] as never)], + ) + expect(rows.map((r) => r.id)).toEqual([idA]) + }) + + it.each( + eqDomains, + )('%s: eql_v3.neq(col, operand) excludes the matching row', async (eqlType) => { + const col = slug(eqlType) + // Operand encrypts `samples[0]` (row idA). `neq` selects every row whose + // value differs, i.e. row idB (`samples[1]`) only — idA is excluded. + const rows = await sql.unsafe( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND eql_v3.neq("${col}", $2::jsonb)`, + [TEST_RUN_ID, sql.json(eqTerms[col] as never)], + ) + expect(rows.map((r) => r.id)).toEqual([idB]) + }) + + it.each( + ordDomains, + )('%s: equality-via-ORE selects the exact row', async (eqlType, spec) => { + const col = slug(eqlType) + // The proof must exercise the ORDER (`ob`) term, not equality. On text order + // domains (`text_ord`/`text_ord_ore`, which carry BOTH `unique` and `ore`) + // `eql_v3.eq` compares the `hm` term, so pin the ORE term with a degenerate + // range `col >= operand AND col <= operand` (both `ord_term`-based) — it + // selects the equal row via ORE. Pure-ORE numeric/date domains have no `hm`, + // so `eql_v3.eq` resolves to `ord_term`: that IS the equality-via-ORE proof. + const predicate = hasIndex(spec.indexes, 'unique') + ? `eql_v3.gte("${col}", $2::jsonb) AND eql_v3.lte("${col}", $2::jsonb)` + : `eql_v3.eq("${col}", $2::jsonb)` + const rows = await sql.unsafe( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND ${predicate}`, + [TEST_RUN_ID, sql.json(ordTerms[col] as never)], + ) + expect(rows.map((r) => r.id)).toEqual([idA]) + }) + + it.each( + textOreDomains, + )('%s: encrypted empty string is rejected by the Postgres domain', async (eqlType) => { + const col = slug(eqlType) + const column = (table as unknown as Record)[col] as never + const encrypted = unwrapResult( + await client.encrypt('', { + table: table as never, + column, + }), + ) + + await expect( + sql.unsafe(`SELECT $1::${eqlType}`, [sql.json(encrypted as never)]), + ).rejects.toThrow(/violates check constraint/) + }) + + it.each( + textOpeDomains, + )('%s: encrypted empty string clears the Postgres domain (scalar op term)', async (eqlType) => { + const col = slug(eqlType) + const column = (table as unknown as Record)[col] as never + const encrypted = unwrapResult( + await client.encrypt('', { + table: table as never, + column, + }), + ) + + const rows = await sql.unsafe(`SELECT $1::${eqlType} AS v`, [ + sql.json(encrypted as never), + ]) + expect(rows).toHaveLength(1) + }) + + it.each( + matchDomains, + )('%s: eql_v3.contains selects the row containing "ada"', async (eqlType, spec) => { + const col = slug(eqlType) + const expectedId = String(spec.samples[0]).includes('ada') ? idA : idB + const rows = await sql.unsafe( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND eql_v3.contains("${col}", $2::jsonb)`, + [TEST_RUN_ID, sql.json(matchTerms[col] as never)], + ) + expect(rows.map((r) => r.id)).toEqual([expectedId]) + }) + + it.each( + matchDomains, + )('%s: eql_v3.contained_by selects the row whose tokens the operand covers', async (eqlType) => { + const col = slug(eqlType) + // `contained_by(col, operand)` (`col <@ operand`) is true when the column's + // bloom tokens are a subset of the operand's. The operand encrypts row idA's + // full `samples[0]` value, so idA (equal token set) is contained_by it, while + // idB (`samples[1]`) carries tokens the operand lacks and is excluded. This is + // the dual of the `contains`/`@>` proof above. + const rows = await sql.unsafe( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND eql_v3.contained_by("${col}", $2::jsonb)`, + [TEST_RUN_ID, sql.json(containedByTerms[col] as never)], + ) + expect(rows.map((r) => r.id)).toEqual([idA]) + }) + + it.each( + orderingDomains, + )('%s: ORE pairwise-lt reproduces plaintext order across all distinct samples', async (eqlType, spec) => { + // STRICT ordering proof: seed each of a domain's distinct sample values as + // its OWN row (orderIds[0..L-1] ↔ samples[0..L-1]) and prove the ORE + // comparison reproduces the FULL plaintext order (a orderIds[i]). + const expectedAscending = spec.samples + .map((value, i) => ({ value, id: ids[i] })) + .sort((x, y) => comparePlaintext(x.value, y.value)) + .map((entry) => entry.id) + + const pairs = await sql.unsafe< + Array<{ a: number; b: number; lt: boolean }> + >( + `SELECT x.id AS a, y.id AS b, eql_v3.lt(x."${col}", y."${col}") AS lt + FROM ${TABLE_NAME} x + CROSS JOIN ${TABLE_NAME} y + WHERE x.test_run_id = $1 + AND y.test_run_id = $1 + AND x.id = ANY($2) + AND y.id = ANY($2) + AND x.id <> y.id`, + [ORDER_RUN_ID, ids], + ) + + const lessThanCount = new Map(ids.map((id) => [id, 0])) + for (const pair of pairs) { + if (pair.lt) { + lessThanCount.set(pair.a, (lessThanCount.get(pair.a) ?? 0) + 1) + } + } + + // Ascending rank = strictly-less-than count, descending (the smallest value + // is < every other row, so it has the highest count and sorts first). + const derivedAscending = [...ids].sort( + (a, b) => (lessThanCount.get(b) ?? 0) - (lessThanCount.get(a) ?? 0), + ) + + // Sanity: distinct samples must yield distinct ranks 0..L-1 (a strict total + // order), otherwise the ORE comparison collapsed two values together. + expect(new Set(lessThanCount.values()).size).toBe(L) + expect(derivedAscending).toEqual(expectedAscending) + }) + + it.each( + orderingDomains, + )('%s: eql_v3.gte/lte (inclusive) and gt/lt (exclusive) bound the ORE range', async (eqlType, spec) => { + // Explicit two-bound ORE range over the distinct-sample rows: `[lo, hi]` + // spans the whole set, so gte+lte must select ALL of them and strict gt+lt + // must select only the interior (excluding the lo and hi rows). Bounds are + // the plaintext-min/max samples; membership is compared to the plaintext + // order. Uses the boolean comparison operators (ORE-correct on superuser AND + // non-superuser Postgres) — never `ORDER BY ord_term`. For L=2 domains + // (date/timestamp) the interior is empty: a valid exclusive-bound boundary. + const col = slug(eqlType) + const L = spec.samples.length + const ids = orderIds.slice(0, L) + const operands = orderOperands[col] + + const sortedIdx = spec.samples + .map((value, i) => ({ value, i })) + .sort((a, b) => comparePlaintext(a.value, b.value)) + .map((entry) => entry.i) + const lo = sql.json(operands[sortedIdx[0]] as never) + const hi = sql.json(operands[sortedIdx[L - 1]] as never) + + // Inclusive [lo, hi] → every distinct-sample row. + const inclusive = await sql.unsafe( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND id = ANY($2) + AND eql_v3.gte("${col}", $3::jsonb) + AND eql_v3.lte("${col}", $4::jsonb)`, + [ORDER_RUN_ID, ids, lo, hi], + ) + expect(new Set(inclusive.map((r) => r.id))).toEqual(new Set(ids)) + + // Exclusive (lo, hi) via strict gt/lt → strictly-interior rows only. + const interiorIds = sortedIdx.slice(1, L - 1).map((i) => ids[i]) + const exclusive = await sql.unsafe( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND id = ANY($2) + AND eql_v3.gt("${col}", $3::jsonb) + AND eql_v3.lt("${col}", $4::jsonb)`, + [ORDER_RUN_ID, ids, lo, hi], + ) + expect(new Set(exclusive.map((r) => r.id))).toEqual(new Set(interiorIds)) + + // The controls. Domains with only two distinct samples (date, timestamp) + // have an empty interior, so the assertion above is satisfied by a + // constant-false `gt`/`lt` as well as by a correct one. One-sided strict + // bounds are non-empty for every domain: `gt(lo)` must return everything + // above the minimum, `lt(hi)` everything below the maximum. Both die on a + // constant-false operator, and on a constant-true one (which would drag in + // the excluded endpoint). + const aboveLo = await sql.unsafe( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND id = ANY($2) + AND eql_v3.gt("${col}", $3::jsonb)`, + [ORDER_RUN_ID, ids, lo], + ) + expect(new Set(aboveLo.map((r) => r.id))).toEqual( + new Set(sortedIdx.slice(1).map((i) => ids[i])), + ) + + const belowHi = await sql.unsafe( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND id = ANY($2) + AND eql_v3.lt("${col}", $3::jsonb)`, + [ORDER_RUN_ID, ids, hi], + ) + expect(new Set(belowHi.map((r) => r.id))).toEqual( + new Set(sortedIdx.slice(0, L - 1).map((i) => ids[i])), + ) + }) + + it.each( + storageDomains, + )('%s: ciphertext survives a real INSERT/SELECT and still decrypts', async (eqlType, spec) => { + const col = slug(eqlType) + const [row] = await sql.unsafe>( + `SELECT "${col}"::jsonb AS value FROM ${TABLE_NAME} WHERE id = $1`, + [idA], + ) + const decrypted = unwrapResult(await client.decrypt(row.value as never)) + const expected = spec.samples[0] + expectDecryptedStorageValue(decrypted, expected) + }) +}) diff --git a/packages/stack/integration/shared/ope-term.integration.test.ts b/packages/stack/integration/shared/ope-term.integration.test.ts new file mode 100644 index 000000000..64c6afa0a --- /dev/null +++ b/packages/stack/integration/shared/ope-term.integration.test.ts @@ -0,0 +1,99 @@ +import { expect, it } from 'vitest' +import { EncryptionV3 } from '@/encryption/v3' +import { encryptedTable, types } from '@/eql/v3' + +/** + * The property that makes `order=col->op` correct, asserted on the term itself. + * + * The Supabase adapter orders an encrypted column by its `op` term where it sits + * inside the envelope, because PostgREST cannot emit the canonical + * `ORDER BY eql_v3.ord_term(col)` — it cannot call a function. `ord_term()` + * returns `eql_v3_internal.ope_cllw`, a domain over `bytea`, ordered by the + * native btree. The jsonb path orders the same term as a STRING. + * + * Those agree only because of how the term is encoded. Postgres compares jsonb + * strings with `varstr_cmp` under the database's default collation — `->` does + * NOT avoid collation any more than `->>` does (measured: with `en_US.UTF-8`, + * both order `'a'` before `'B'`, while `COLLATE "C"` does the reverse). What + * saves us is that the term is FIXED-WIDTH LOWERCASE HEX: + * + * - fixed width, so lexicographic order is positional order — no prefix effects; + * - `[0-9a-f]` only, and every collation orders digits before letters and hex + * letters among themselves. + * + * Change the term's encoding — variable width, uppercase, base64 — and ordering + * through PostgREST silently stops matching `ord_term()`. This test is the + * tripwire. The Drizzle adapter emits `ord_term()` directly and is unaffected. + */ +const table = encryptedTable('ope_term_probe', { + amount: types.IntegerOrd('amount'), + when: types.TimestampOrd('when'), + name: types.TextSearch('name'), +}) + +const HEX = /^[0-9a-f]+$/ + +async function opTerms( + values: readonly unknown[], + column: 'amount' | 'when' | 'name', +) { + const client = await EncryptionV3({ schemas: [table] }) + const terms: string[] = [] + for (const value of values) { + const result = await client.encrypt(value as never, { + column: table[column], + table, + }) + if (result.failure) throw new Error(result.failure.message) + terms.push((result.data as { op: string }).op) + } + return terms +} + +it('integer_ord op terms are fixed-width lowercase hex', async () => { + const terms = await opTerms([-2147483648, -1, 0, 1, 2147483647], 'amount') + + expect(terms.every((term) => HEX.test(term))).toBe(true) + expect(new Set(terms.map((term) => term.length)).size).toBe(1) +}, 300_000) + +it('timestamp_ord op terms are fixed-width lowercase hex', async () => { + const stamps = await opTerms( + [new Date('1970-01-01T00:00:00Z'), new Date('2026-07-10T12:34:56Z')], + 'when', + ) + + expect(stamps.every((term) => HEX.test(term))).toBe(true) + expect(new Set(stamps.map((term) => term.length)).size).toBe(1) +}, 300_000) + +/** + * Text terms are VARIABLE width — 16 hex chars per character, plus a 2-char + * header (`'ada'` -> 50, `'zebra'` -> 82). That is not a defect: the blocks are + * positional, so comparing the terms as strings compares the plaintexts + * character by character, and a shorter term that is a prefix of a longer one + * sorts first — exactly the semantics of comparing the strings themselves. + * + * Numeric and date terms must stay FIXED width, because there positional + * comparison is only equivalent to numeric comparison when every term has the + * same number of blocks. + */ +it('text op terms are hex, per-character, and order like their plaintexts', async () => { + // Includes the prefix case (`ada` < `adam`), which is the one variable width + // could plausibly get wrong. + const ascending = ['ada', 'adam', 'zebra'] + const terms = await opTerms(ascending, 'name') + + expect(terms.every((term) => HEX.test(term))).toBe(true) + expect(terms.map((term) => term.length)).toEqual([50, 66, 82]) + expect([...terms].sort()).toEqual(terms) +}, 300_000) + +it('lexicographic order over the op terms reproduces plaintext order', async () => { + // The whole point, stated directly: sorting the terms as strings — which is + // what PostgREST does — must agree with sorting the plaintexts. + const ascending = [-2147483648, -1, 0, 1, 2147483647] + const terms = await opTerms(ascending, 'amount') + + expect([...terms].sort()).toEqual(terms) +}, 300_000) diff --git a/packages/stack/__tests__/schema-v3-pg.test.ts b/packages/stack/integration/shared/schema-pg.integration.test.ts similarity index 50% rename from packages/stack/__tests__/schema-v3-pg.test.ts rename to packages/stack/integration/shared/schema-pg.integration.test.ts index a971cae94..a034411d6 100644 --- a/packages/stack/__tests__/schema-v3-pg.test.ts +++ b/packages/stack/integration/shared/schema-pg.integration.test.ts @@ -1,18 +1,12 @@ -import 'dotenv/config' +import { databaseUrl, unwrapResult } from '@cipherstash/test-kit' import postgres from 'postgres' import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest' import type { EncryptionClient } from '@/encryption' import { encryptedTable, types } from '@/eql/v3' import { Encryption } from '@/index' import type { Encrypted } from '@/types' -import { unwrapResult } from './fixtures' -import { assertV3WireEnvelope, installEqlV3IfNeeded } from './helpers/eql-v3' -import { describeLivePg, LIVE_EQL_V3_PG_ENABLED } from './helpers/live-gate' -const databaseUrl = process.env.DATABASE_URL -const sql = LIVE_EQL_V3_PG_ENABLED - ? postgres(databaseUrl as string, { prepare: false }) - : (undefined as unknown as postgres.Sql) +const sql = postgres(databaseUrl(), { prepare: false }) const table = encryptedTable('protect_ci_v3_text_search', { email: types.TextSearch('email'), @@ -35,36 +29,29 @@ type InsertedRow = { type EncryptionPayload = postgres.JSONValue let protectClient: EncryptionClient -// INTERIM (CIP-3402): protect-ffi 0.27 has no v3 scalar query wire shape — -// scalar encryptQuery on a v3-wire client throws EQL_V3_QUERY_UNSUPPORTED. -// Query terms are built with a second, explicitly v2-wire client over the -// same schemas; the eql_v3_internal extractors these tests feed terms to -// (hmac_256 / bloom_filter / ore_block_256) read only the term keys from the -// jsonb, and index terms are identical across wire formats. -let termClient: EncryptionClient async function encryptValue(value: string): Promise { - const payload = unwrapResult( + return unwrapResult( await protectClient.encrypt(value, { table, column: table.email, }), ) as EncryptionPayload - // Generation handshake: fail loudly on client/bundle wire-format skew. - assertV3WireEnvelope(payload, 'schema-v3-pg encryptValue') - return payload } -async function encryptQueryTerm( - value: string, - queryType?: 'equality' | 'freeTextSearch' | 'orderAndRange', +// A query operand under EQL v3 is a FULL encrypted payload — the same thing +// `client.encrypt` produces for storage. (protect-ffi 0.29 can also mint +// term-only `eql_v3.query_` operands via `encryptQuery`; this suite +// keeps the full-envelope path because it is what the stack's integrations +// send.) Compare it to a column with the public two-arg +// `eql_v3.*(col, operand::jsonb)` functions; the operand carries every index +// term, so which SQL function you call selects which term is compared. +async function encryptOperand( + value: unknown, + opts: Parameters[1], ): Promise { return unwrapResult( - await termClient.encryptQuery(value, { - table, - column: table.email, - queryType, - }), + await protectClient.encrypt(value as never, opts), ) as EncryptionPayload } @@ -73,7 +60,7 @@ async function insertRow(label: string, email: string): Promise { const [inserted] = await sql<{ id: number }[]>` INSERT INTO protect_ci_v3_text_search (email, label, test_run_id) - VALUES (${sql.json(encrypted)}::eql_v3.text_search, ${label}, ${TEST_RUN_ID}) + VALUES (${sql.json(encrypted)}::public.eql_v3_text_search, ${label}, ${TEST_RUN_ID}) RETURNING id ` @@ -100,20 +87,27 @@ async function seedRows(): Promise> { } beforeAll(async () => { - if (!LIVE_EQL_V3_PG_ENABLED) return - - await installEqlV3IfNeeded(sql) - protectClient = await Encryption({ schemas: [table, typedTable] }) - // v2-wire term client (see the INTERIM note above the declarations). - termClient = await Encryption({ + // EQL v3 is installed once per run by `global-setup.ts`. + // `eqlVersion: 3` is required for v3 concrete-type schemas: protect-ffi's + // newClient defaults to v2, and a v2-mode client cannot encrypt these columns + // (it throws "Cannot convert undefined or null to object"). EncryptionV3 sets + // this automatically; the base `Encryption` factory does not, so pass it here. + protectClient = await Encryption({ schemas: [table, typedTable], - config: { eqlVersion: 2 }, + config: { eqlVersion: 3 }, }) + // DROP first: these tables are created with IF NOT EXISTS and cleaned up by + // row DELETE only, so one left by an earlier local run keeps its OLD column + // domain types across the `eql_v3.* -> public.*` rename — silently testing a + // stale schema. Harmless in CI (fresh Postgres); reliable local reruns. + await sql`DROP TABLE IF EXISTS protect_ci_v3_text_search` + await sql`DROP TABLE IF EXISTS protect_ci_v3_typed_domains` + await sql` CREATE TABLE IF NOT EXISTS protect_ci_v3_text_search ( id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, - email eql_v3.text_search NOT NULL, + email public.eql_v3_text_search NOT NULL, label TEXT NOT NULL, test_run_id TEXT NOT NULL ) @@ -122,17 +116,15 @@ beforeAll(async () => { await sql` CREATE TABLE IF NOT EXISTS protect_ci_v3_typed_domains ( id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, - age eql_v3.integer_ord NOT NULL, - nickname eql_v3.text_eq NOT NULL, - active eql_v3.boolean NOT NULL, + age public.eql_v3_integer_ord NOT NULL, + nickname public.eql_v3_text_eq NOT NULL, + active public.eql_v3_boolean NOT NULL, test_run_id TEXT NOT NULL ) ` }, 30000) beforeEach(async () => { - if (!LIVE_EQL_V3_PG_ENABLED) return - await sql` DELETE FROM protect_ci_v3_text_search WHERE test_run_id = ${TEST_RUN_ID} @@ -144,8 +136,6 @@ beforeEach(async () => { }, 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} @@ -157,8 +147,8 @@ afterAll(async () => { 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 () => { +describe('eql_v3 text_search postgres integration', () => { + it('round-trips an encrypted value through an public.eql_v3_text_search column', async () => { const id = await insertRow('roundtrip', 'roundtrip@example.com') const [row] = await sql` @@ -171,15 +161,18 @@ describeLivePg('eql_v3 text_search postgres integration', () => { await expect(decryptRow(row)).resolves.toBe('roundtrip@example.com') }, 30000) - it('queries equality terms with eql_v3.eq_term and eql_v3_internal.hmac_256', async () => { + it('queries equality with eql_v3.eq and a full operand', async () => { const ids = await seedRows() - const equalityTerm = await encryptQueryTerm('grace@example.com', 'equality') + const operand = await encryptOperand('grace@example.com', { + table, + column: table.email, + }) const rows = await sql` SELECT id, email::jsonb AS email, label FROM protect_ci_v3_text_search WHERE test_run_id = ${TEST_RUN_ID} - AND eql_v3.eq_term(email) = eql_v3_internal.hmac_256(${sql.json(equalityTerm)}::jsonb) + AND eql_v3.eq(email, ${sql.json(operand)}::jsonb) ORDER BY id ` @@ -187,38 +180,92 @@ describeLivePg('eql_v3 text_search postgres integration', () => { await expect(decryptRow(rows[0])).resolves.toBe('grace@example.com') }, 30000) - it('queries free-text terms with eql_v3.match_term and eql_v3_internal.bloom_filter', async () => { + it('queries free-text with eql_v3.contains and a full operand', async () => { await seedRows() - const matchTerm = await encryptQueryTerm('example.com', 'freeTextSearch') + const operand = await encryptOperand('example.com', { + table, + column: table.email, + }) const rows = await sql` SELECT id, email::jsonb AS email, label FROM protect_ci_v3_text_search WHERE test_run_id = ${TEST_RUN_ID} - AND eql_v3.match_term(email) @> eql_v3_internal.bloom_filter(${sql.json(matchTerm)}::jsonb) + AND eql_v3.contains(email, ${sql.json(operand)}::jsonb) ORDER BY label ` expect(rows.map((row) => row.label)).toEqual(['ada', 'grace']) }, 30000) - it('queries range terms with eql_v3.ord_term and eql_v3_internal.ore_block_256', async () => { + it('queries range with eql_v3.gte/lte and full operands', async () => { await seedRows() - const lower = await encryptQueryTerm('grace@example.com', 'orderAndRange') - const upper = await encryptQueryTerm('zora@example.org', 'orderAndRange') + const lower = await encryptOperand('grace@example.com', { + table, + column: table.email, + }) + const upper = await encryptOperand('zora@example.org', { + table, + column: table.email, + }) const rows = await sql` SELECT id, email::jsonb AS email, label FROM protect_ci_v3_text_search WHERE test_run_id = ${TEST_RUN_ID} - AND eql_v3.ord_term(email) >= eql_v3_internal.ore_block_256(${sql.json(lower)}::jsonb) - AND eql_v3.ord_term(email) <= eql_v3_internal.ore_block_256(${sql.json(upper)}::jsonb) - ORDER BY eql_v3.ord_term(email) + AND eql_v3.gte(email, ${sql.json(lower)}::jsonb) + AND eql_v3.lte(email, ${sql.json(upper)}::jsonb) + ORDER BY label ` + // Assert range MEMBERSHIP deterministically by ordering on the plaintext + // `label`. The range predicate above (eql_v3.gte/lte) already proves the ORE + // comparison is lexically correct: it selects grace+zora and excludes + // ada/alan. + // + // NB: we deliberately do NOT order by `eql_v3.ord_term(email)` (nor by the + // `email` column, nor `email USING <`). None of those yield ORE order on a + // non-superuser Postgres: `ord_term` returns the composite + // `eql_v3_internal.ore_block_256`, whose ORE-aware btree opclass is + // superuser-gated and skipped on managed installs, so `ORDER BY ord_term` + // silently falls back to PostgreSQL's built-in record comparison (raw-byte + // order, not ORE). See docs/eql-v3-ord-term-ordering-defect.md. expect(rows.map((row) => row.label)).toEqual(['grace', 'zora']) }, 30000) + it('proves ORE total order via pairwise eql_v3.lt (ord_term ORDER BY is NOT ORE order)', async () => { + // The ORE comparison operators are ORE-correct even where `ORDER BY + // ord_term(col)` is not (see docs/eql-v3-ord-term-ordering-defect.md). + // Reconstruct the total order purely from boolean `eql_v3.lt` predicates: a + // self cross-join gives, for each ordered pair, whether x < y under ORE; the + // count of rows a label is strictly-less-than is its ascending rank. + await seedRows() + + const pairs = await sql<{ a: string; b: string; lt: boolean }[]>` + SELECT x.label AS a, y.label AS b, eql_v3.lt(x.email, y.email) AS lt + FROM protect_ci_v3_text_search x + CROSS JOIN protect_ci_v3_text_search y + WHERE x.test_run_id = ${TEST_RUN_ID} + AND y.test_run_id = ${TEST_RUN_ID} + AND x.label <> y.label + ` + + const labels = ['ada', 'grace', 'alan', 'zora'] + const lessThanCount = new Map(labels.map((l) => [l, 0])) + for (const pair of pairs) { + if (pair.lt) + lessThanCount.set(pair.a, (lessThanCount.get(pair.a) ?? 0) + 1) + } + + const ascending = [...lessThanCount.entries()] + .sort(([, aRank], [, bRank]) => bRank - aRank) + .map(([label]) => label) + + // Lexical/ORE order of the seeded emails: + // ada@example.com < alan@example.net < grace@example.com < zora@example.org + expect(ascending).toEqual(['ada', 'alan', 'grace', 'zora']) + }, 30000) + it('creates functional indexes for equality, match, and order terms', async () => { await sql` CREATE INDEX IF NOT EXISTS protect_ci_v3_text_search_email_eq_idx @@ -233,11 +280,22 @@ describeLivePg('eql_v3 text_search postgres integration', () => { ON protect_ci_v3_text_search USING btree (eql_v3.ord_term(email)) ` + // Scope to the schema THIS run's table actually landed in, rather than + // hardcoding `public`. The table is created unqualified, so it lands in + // whatever `search_path` puts first — `public` on a fresh CI database, but + // the owning role's own schema (`cipherstash`) on a database whose + // search_path is `"$user", public`; a hardcoded `schemaname = 'public'` made + // the assertion environment-dependent. Deriving the schema from `pg_tables` + // keeps it environment-independent AND avoids a false pass from a same-named + // index left in another schema by an earlier run on a shared/persistent DB. const indexes = await sql<{ indexname: string; indexdef: string }[]>` SELECT indexname, indexdef FROM pg_indexes - WHERE schemaname = 'public' - AND tablename = 'protect_ci_v3_text_search' + WHERE tablename = 'protect_ci_v3_text_search' + AND schemaname = ( + SELECT schemaname FROM pg_tables + WHERE 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', @@ -257,14 +315,21 @@ describeLivePg('eql_v3 text_search postgres integration', () => { ) }, 30000) - it('rejects query-only payloads cast as eql_v3.text_search values', async () => { - const equalityTerm = await encryptQueryTerm('ada@example.com', 'equality') + it('rejects a ciphertext-less payload cast as a public.eql_v3_text_search value', async () => { + // A full operand with its ciphertext (`c`) removed mimics a query-only + // payload: index terms present, no stored value. The domain CHECK must + // reject it, so it can never masquerade as a stored ciphertext. + const full = (await encryptOperand('ada@example.com', { + table, + column: table.email, + })) as Record + const { c: _ciphertext, ...ciphertextLess } = full await expect( sql` INSERT INTO protect_ci_v3_text_search (email, label, test_run_id) VALUES ( - ${sql.json(equalityTerm)}::eql_v3.text_search, + ${sql.json(ciphertextLess as EncryptionPayload)}::public.eql_v3_text_search, 'query-only', ${TEST_RUN_ID} ) @@ -295,37 +360,35 @@ describeLivePg('eql_v3 text_search postgres integration', () => { const [inserted] = await sql<{ id: number }[]>` INSERT INTO protect_ci_v3_typed_domains (age, nickname, active, test_run_id) VALUES ( - ${sql.json(age as postgres.JSONValue)}::eql_v3.integer_ord, - ${sql.json(nickname as postgres.JSONValue)}::eql_v3.text_eq, - ${sql.json(active as postgres.JSONValue)}::eql_v3.boolean, + ${sql.json(age as postgres.JSONValue)}::public.eql_v3_integer_ord, + ${sql.json(nickname as postgres.JSONValue)}::public.eql_v3_text_eq, + ${sql.json(active as postgres.JSONValue)}::public.eql_v3_boolean, ${TEST_RUN_ID} ) RETURNING id ` - const ageTerm = unwrapResult( - await termClient.encryptQuery(30, { - table: typedTable, - column: typedTable.age, - queryType: 'orderAndRange', - }), - ) as postgres.JSONValue + const ageTerm = await encryptOperand(30, { + table: typedTable, + column: typedTable.age, + }) const rows = await sql<{ id: number }[]>` SELECT id FROM protect_ci_v3_typed_domains WHERE test_run_id = ${TEST_RUN_ID} - AND eql_v3.ord_term(age) >= eql_v3_internal.ore_block_256(${sql.json(ageTerm)}::jsonb) + AND eql_v3.gte(age, ${sql.json(ageTerm)}::jsonb) ` expect(rows.map((row) => row.id)).toContain(inserted.id) }, 30000) - // Correctness proof for the equality-via-ORE fix (Part A). The deterministic - // regression proves `resolveIndexType` resolves equality to `ore` instead of - // throwing; this proves the resulting term actually SELECTS the right rows - // against real Postgres, using the SQL `=` operator on the ORE term. - it('selects the exact row for an equality term via ORE on an integer_ord column', async () => { + // Correctness proof for equality-via-ORE on an `integer_ord` column. The + // `integer_ord` domain carries only an `ore` (`ob`) index and no `hm`, so + // `eql_v3.eq(integer_ord, operand)` internally compares `ord_term` — i.e. + // equality answered through ORE. This proves that resolves the exact row + // against real Postgres with a full operand (no `encryptQuery` term). + it('selects the exact row for equality-via-ORE on an integer_ord column', async () => { async function insertAge(age: number): Promise { const ageCt = unwrapResult( await protectClient.encrypt(age, { @@ -348,9 +411,9 @@ describeLivePg('eql_v3 text_search postgres integration', () => { const [row] = await sql<{ id: number }[]>` INSERT INTO protect_ci_v3_typed_domains (age, nickname, active, test_run_id) VALUES ( - ${sql.json(ageCt)}::eql_v3.integer_ord, - ${sql.json(nick)}::eql_v3.text_eq, - ${sql.json(act)}::eql_v3.boolean, + ${sql.json(ageCt)}::public.eql_v3_integer_ord, + ${sql.json(nick)}::public.eql_v3_text_eq, + ${sql.json(act)}::public.eql_v3_boolean, ${TEST_RUN_ID} ) RETURNING id @@ -364,21 +427,18 @@ describeLivePg('eql_v3 text_search postgres integration', () => { fortyTwo: await insertAge(42), } - // Equality term encrypted with queryType:'equality' — post-fix this resolves - // to the ore (`ob`) term; the SQL `=` operator makes it an equality match. - const equalityTerm = unwrapResult( - await termClient.encryptQuery(37, { - table: typedTable, - column: typedTable.age, - queryType: 'equality', - }), - ) as postgres.JSONValue + // Full operand for 37; `eql_v3.eq(integer_ord, operand)` compares `ord_term`, + // so this is equality answered via ORE. + const equalityTerm = await encryptOperand(37, { + table: typedTable, + column: typedTable.age, + }) const matched = await sql<{ id: number }[]>` SELECT id FROM protect_ci_v3_typed_domains WHERE test_run_id = ${TEST_RUN_ID} - AND eql_v3.ord_term(age) = eql_v3_internal.ore_block_256(${sql.json(equalityTerm)}::jsonb) + AND eql_v3.eq(age, ${sql.json(equalityTerm)}::jsonb) ORDER BY id ` // Exactly the age=37 row — not the 30 or 42 rows. @@ -387,18 +447,15 @@ describeLivePg('eql_v3 text_search postgres integration', () => { expect(matched.map((row) => row.id)).not.toContain(ids.fortyTwo) // A non-matching value selects nothing. - const missTerm = unwrapResult( - await termClient.encryptQuery(99, { - table: typedTable, - column: typedTable.age, - queryType: 'equality', - }), - ) as postgres.JSONValue + const missTerm = await encryptOperand(99, { + table: typedTable, + column: typedTable.age, + }) const none = await sql<{ id: number }[]>` SELECT id FROM protect_ci_v3_typed_domains WHERE test_run_id = ${TEST_RUN_ID} - AND eql_v3.ord_term(age) = eql_v3_internal.ore_block_256(${sql.json(missTerm)}::jsonb) + AND eql_v3.eq(age, ${sql.json(missTerm)}::jsonb) ` expect(none).toHaveLength(0) }, 30000) diff --git a/packages/stack/__tests__/schema-v3-client.test.ts b/packages/stack/integration/shared/schema-v3-client.integration.test.ts similarity index 78% rename from packages/stack/__tests__/schema-v3-client.test.ts rename to packages/stack/integration/shared/schema-v3-client.integration.test.ts index b4838abdb..839ded21a 100644 --- a/packages/stack/__tests__/schema-v3-client.test.ts +++ b/packages/stack/integration/shared/schema-v3-client.integration.test.ts @@ -1,11 +1,9 @@ -import 'dotenv/config' +import { unwrapResult } from '@cipherstash/test-kit' import { beforeAll, describe, expect, it } from 'vitest' import type { EncryptionClient } from '@/encryption' import { typedClient } from '@/encryption/v3' import { encryptedTable, types } from '@/eql/v3' import { Encryption } from '@/index' -import { unwrapResult } from './fixtures' -import { describeLive, LIVE_CIPHERSTASH_ENABLED } from './helpers/live-gate' const users = encryptedTable('schema_v3_client_users', { email: types.TextSearch('email'), @@ -21,20 +19,11 @@ const users = encryptedTable('schema_v3_client_users', { occurredAt: types.Timestamp('occurred_at'), }) -describeLive('eql_v3 client integration', () => { +describe('eql_v3 client integration', () => { let protectClient: EncryptionClient - // INTERIM (CIP-3402): protect-ffi 0.27 has no v3 scalar query wire shape — - // scalar encryptQuery on the v3-wire client throws EQL_V3_QUERY_UNSUPPORTED. - // Query-term shape assertions run against a second, explicitly v2-wire client - // over the same schemas (index terms are identical across wire formats). - let termClient: EncryptionClient beforeAll(async () => { protectClient = await Encryption({ schemas: [users] }) - termClient = await Encryption({ - schemas: [users], - config: { eqlVersion: 2 }, - }) }) it('encrypts and decrypts a text_search column', async () => { @@ -47,13 +36,13 @@ describeLive('eql_v3 client integration', () => { expect(encrypted).toMatchObject({ i: { t: 'schema_v3_client_users', c: 'email' }, - // v3-wire storage envelope (eqlVersion: 3 client over v3 schemas) v: 3, }) expect(encrypted).toHaveProperty('c') expect(encrypted).toHaveProperty('hm') expect(encrypted).toHaveProperty('bf') - expect(encrypted).toHaveProperty('ob') + // eql-3.0.0: text_search is OPE-backed — `op`, not the block-ORE `ob`. + expect(encrypted).toHaveProperty('op') const decrypted = unwrapResult(await protectClient.decrypt(encrypted)) expect(decrypted).toBe('ada@example.com') @@ -61,7 +50,7 @@ describeLive('eql_v3 client integration', () => { it('auto-infers equality query terms for text_search columns', async () => { const queryTerm = unwrapResult( - await termClient.encryptQuery('ada@example.com', { + await protectClient.encryptQuery('ada@example.com', { table: users, column: users.email, }), @@ -69,29 +58,15 @@ describeLive('eql_v3 client integration', () => { expect(queryTerm).toMatchObject({ i: { t: 'schema_v3_client_users', c: 'email' }, - // v2-wire: terms come from the interim v2 term client (CIP-3402) - v: 2, + v: 3, }) expect(queryTerm).toHaveProperty('hm') expect(queryTerm).not.toHaveProperty('c') }, 30000) - it('rejects scalar encryptQuery on the v3-wire client (no v3 scalar query wire shape yet)', async () => { - // Pins the FFI behaviour the Supabase adapter's interim full-envelope - // operand path depends on: under eqlVersion 3, scalar index queries - // throw EQL_V3_QUERY_UNSUPPORTED until an EQL scalar query envelope - // exists (CIP-3402). - const result = await protectClient.encryptQuery('ada@example.com', { - table: users, - column: users.email, - }) - expect(result.failure).toBeDefined() - expect(result.failure?.message).toMatch(/unsupported|eqlVersion/i) - }, 30000) - it('encrypts explicit freeTextSearch and orderAndRange query terms', async () => { const matchTerm = unwrapResult( - await termClient.encryptQuery('Ada Lovelace', { + await protectClient.encryptQuery('Ada Lovelace', { table: users, column: users.email, queryType: 'freeTextSearch', @@ -99,7 +74,7 @@ describeLive('eql_v3 client integration', () => { ) const orderTerm = unwrapResult( - await termClient.encryptQuery('ada@example.com', { + await protectClient.encryptQuery('ada@example.com', { table: users, column: users.email, queryType: 'orderAndRange', @@ -108,7 +83,7 @@ describeLive('eql_v3 client integration', () => { expect(matchTerm).toHaveProperty('bf') expect(matchTerm).not.toHaveProperty('c') - expect(orderTerm).toHaveProperty('ob') + expect(orderTerm).toHaveProperty('op') expect(orderTerm).not.toHaveProperty('c') }, 30000) @@ -127,6 +102,7 @@ describeLive('eql_v3 client integration', () => { expect(encryptedText).not.toHaveProperty('hm') expect(encryptedText).not.toHaveProperty('bf') expect(encryptedText).not.toHaveProperty('ob') + expect(encryptedText).not.toHaveProperty('op') expect(unwrapResult(await protectClient.decrypt(encryptedText))).toBe( 'private note', ) @@ -143,7 +119,7 @@ describeLive('eql_v3 client integration', () => { it('encrypts equality and order query terms for typed v3 columns', async () => { const equalityTerm = unwrapResult( - await termClient.encryptQuery('ada', { + await protectClient.encryptQuery('ada', { table: users, column: users.nickname, }), @@ -152,13 +128,13 @@ describeLive('eql_v3 client integration', () => { expect(equalityTerm).not.toHaveProperty('c') const orderTerm = unwrapResult( - await termClient.encryptQuery(37, { + await protectClient.encryptQuery(37, { table: users, column: users.age, queryType: 'orderAndRange', }), ) - expect(orderTerm).toHaveProperty('ob') + expect(orderTerm).toHaveProperty('op') expect(orderTerm).not.toHaveProperty('c') }, 30000) @@ -173,9 +149,10 @@ describeLive('eql_v3 client integration', () => { expect(encrypted).toHaveProperty('bf') expect(encrypted).not.toHaveProperty('hm') expect(encrypted).not.toHaveProperty('ob') + expect(encrypted).not.toHaveProperty('op') const matchTerm = unwrapResult( - await termClient.encryptQuery('Lovelace', { + await protectClient.encryptQuery('Lovelace', { table: users, column: users.body, queryType: 'freeTextSearch', @@ -185,7 +162,7 @@ describeLive('eql_v3 client integration', () => { expect(matchTerm).not.toHaveProperty('c') }, 30000) - // bigint (int8) storage domains are omitted from the v3 SDK until the native + // 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. @@ -249,12 +226,11 @@ describeLive('eql_v3 client integration', () => { // the `createdOn` date case above. (`matrix-live.test.ts` is the canonical // generic coverage for all timestamp tiers; this pins the named column.) // - // Previously SKIPPED (CI run 28569708268, PR #540): decrypted `occurredAt` - // came back at midnight (`00:00:00.000Z`), losing the time-of-day, because - // every timestamp domain set `cast_as: 'date'` and the native layer - // truncates 'date' values to the calendar date. Re-enabled now that the - // timestamp domains emit the FFI's distinct `cast_as: 'timestamp'` - // (full date+time) variant. + // Time-of-day preservation: every `timestamp` domain now sets + // `cast_as: 'timestamp'` (distinct from `'date'`), so the native FFI keeps the + // full instant instead of truncating to midnight. This test pins that — a + // ms-zeroed `12:34:56` value must round-trip exactly. (Was skipped while every + // timestamp domain wrongly set `cast_as: 'date'`; re-enabled with that fix.) it('round-trips a timestamp occurredAt column through the model path', async () => { const typed = typedClient(protectClient, users) // Zero milliseconds: the FFI drops sub-second precision, so a ms-bearing diff --git a/packages/stack/integration/vitest.config.ts b/packages/stack/integration/vitest.config.ts new file mode 100644 index 000000000..df1a71441 --- /dev/null +++ b/packages/stack/integration/vitest.config.ts @@ -0,0 +1,77 @@ +import { existsSync } from 'node:fs' +import { resolve } from 'node:path' +import { defineConfig } from 'vitest/config' +import { sharedAlias, stackSourceAlias } from '../../../vitest.shared' +import { + integrationHarness, + integrationTestDefaults, +} from '../../test-kit/src/integration/config' + +/** + * Integration suites: real ZeroKMS, real Postgres, real PostgREST. + * + * Deliberately a SEPARATE config from `packages/stack/vitest.config.ts`, which + * excludes `integration/**`. `pnpm test` must stay runnable with no credentials + * and no database; these run only under `test:integration:*`, from their own CI + * jobs. That separation is what lets the integration suites throw on missing + * configuration instead of skipping. + * + * `CS_IT_SUITE` selects which suites run, so one config serves every adapter + * without a second near-identical file. Comma-separated globs; each CI job scopes + * itself to the adapter it provisioned a database for. Locally it defaults to + * everything. + * + * Scoping matters: the Drizzle suites talk straight to Postgres and the Supabase + * suites need PostgREST, so a job running both would have to provision both. + */ +const ROOT = resolve(__dirname, '..') + +const SUITE_GLOBS = ( + process.env['CS_IT_SUITE'] ?? 'integration/**/*.integration.test.ts' +) + .split(',') + .map((glob) => glob.trim()) + .filter(Boolean) + +/** + * Guard against a glob that resolves to nothing — the silent-zero-coverage hole + * the deleted `live-coverage-guard.test.ts` used to backstop. A directory + * renamed/moved (or a typo) while the workflow's `CS_IT_SUITE` still points at + * the old path makes vitest collect the OTHER globs, pass, and drop those suites + * with no signal — `passWithNoTests` only catches the all-empty case, and the + * no-skips reporter only sees files that were collected. + * + * The literal directory prefix of each glob (everything before the first glob + * metacharacter) must exist. This catches the whole-directory rename directly; + * `passWithNoTests: false` (below) still covers a fully-empty run. + */ +for (const glob of SUITE_GLOBS) { + const literalPrefix = glob + .split('/') + .slice( + 0, + glob.split('/').findIndex((seg) => /[*?{}[\]]/.test(seg)), + ) + .join('/') + // No metacharacter at all → the glob is a literal file path; check it whole. + const target = /[*?{}[\]]/.test(glob) ? literalPrefix : glob + if (target && !existsSync(resolve(ROOT, target))) { + throw new Error( + `CS_IT_SUITE glob "${glob}" points at "${target}", which does not exist. ` + + 'A renamed/moved integration directory would otherwise drop its suites ' + + 'from CI silently. Fix the glob (or the directory) so the suites run.', + ) + } +} + +export default defineConfig({ + resolve: { alias: { ...sharedAlias, ...stackSourceAlias } }, + test: { + root: resolve(__dirname, '..'), + // Unlike the adapter packages (fixed glob), stack's integration job scopes to + // its shared/ + identity/ suites via CS_IT_SUITE — hence the guard above. + include: SUITE_GLOBS, + ...integrationHarness, + ...integrationTestDefaults, + }, +}) diff --git a/packages/stack/package.json b/packages/stack/package.json index 7ee99cf6f..1106aaaad 100644 --- a/packages/stack/package.json +++ b/packages/stack/package.json @@ -39,6 +39,9 @@ "errors": [ "./dist/errors/index.d.ts" ], + "adapter-kit": [ + "./dist/adapter-kit.d.ts" + ], "client": [ "./dist/client.d.ts" ], @@ -60,15 +63,9 @@ "types": [ "./dist/types-public.d.ts" ], - "drizzle": [ - "./dist/drizzle/index.d.ts" - ], "dynamodb": [ "./dist/dynamodb/index.d.ts" ], - "supabase": [ - "./dist/supabase/index.d.ts" - ], "wasm-inline": [ "./dist/wasm-inline.d.ts" ] @@ -145,16 +142,6 @@ "default": "./dist/types-public.cjs" } }, - "./drizzle": { - "import": { - "types": "./dist/drizzle/index.d.ts", - "default": "./dist/drizzle/index.js" - }, - "require": { - "types": "./dist/drizzle/index.d.cts", - "default": "./dist/drizzle/index.cjs" - } - }, "./dynamodb": { "import": { "types": "./dist/dynamodb/index.d.ts", @@ -165,16 +152,6 @@ "default": "./dist/dynamodb/index.cjs" } }, - "./supabase": { - "import": { - "types": "./dist/supabase/index.d.ts", - "default": "./dist/supabase/index.js" - }, - "require": { - "types": "./dist/supabase/index.d.cts", - "default": "./dist/supabase/index.cjs" - } - }, "./encryption": { "import": { "types": "./dist/encryption/index.d.ts", @@ -195,6 +172,16 @@ "default": "./dist/errors/index.cjs" } }, + "./adapter-kit": { + "import": { + "types": "./dist/adapter-kit.d.ts", + "default": "./dist/adapter-kit.js" + }, + "require": { + "types": "./dist/adapter-kit.d.cts", + "default": "./dist/adapter-kit.cjs" + } + }, "./wasm-inline": { "import": { "types": "./dist/wasm-inline.d.ts", @@ -207,21 +194,28 @@ "prebuild": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"", "build": "tsup", "dev": "tsup --watch", - "analyze:complexity": "fta src/eql/v3 --score-cap 72", + "analyze:complexity": "fta src/eql/v3 --score-cap 69", "db:eql-v3:install": "tsx scripts/install-eql-v3.ts", "test": "vitest run", "test:types": "vitest --run --typecheck.only", - "release": "tsup" + "release": "tsup", + "test:integration": "vitest run --config integration/vitest.config.ts" }, "devDependencies": { + "@cipherstash/eql": "3.0.0", "@clack/prompts": "^1.4.0", + "@clerk/backend": "3.4.9", + "@supabase/postgrest-js": "2.105.4", "@supabase/supabase-js": "^2.110.0", + "@types/pg": "^8.20.0", "@types/uuid": "^11.0.0", "dotenv": "17.4.2", "drizzle-orm": "^0.45.2", "execa": "^9.5.2", + "fast-check": "^4.8.0", "fta-cli": "3.0.0", "json-schema-to-typescript": "^15.0.2", + "pg": "8.20.0", "postgres": "^3.4.8", "tsup": "catalog:repo", "tsx": "catalog:repo", @@ -234,7 +228,7 @@ "dependencies": { "@byteslice/result": "0.2.0", "@cipherstash/auth": "catalog:repo", - "@cipherstash/protect-ffi": "0.28.0", + "@cipherstash/protect-ffi": "0.29.0", "evlog": "1.11.0", "uuid": "14.0.0", "zod": "3.25.76" @@ -248,18 +242,6 @@ "@cipherstash/auth-linux-x64-musl": "catalog:repo", "@cipherstash/auth-win32-x64-msvc": "catalog:repo" }, - "peerDependencies": { - "@supabase/supabase-js": ">=2", - "drizzle-orm": ">=0.33" - }, - "peerDependenciesMeta": { - "drizzle-orm": { - "optional": true - }, - "@supabase/supabase-js": { - "optional": true - } - }, "engines": { "node": ">=22" } diff --git a/packages/stack/scripts/install-eql-v3.ts b/packages/stack/scripts/install-eql-v3.ts index e55eba79f..2df1b1324 100644 --- a/packages/stack/scripts/install-eql-v3.ts +++ b/packages/stack/scripts/install-eql-v3.ts @@ -10,6 +10,7 @@ config({ path: '.env.development.local', quiet: true }) config({ path: '.env.development', quiet: true }) config({ path: '.env', quiet: true }) +import { releaseManifest } from '@cipherstash/eql/sql' import postgres from 'postgres' import { installEqlV3IfNeeded } from '../__tests__/helpers/eql-v3' @@ -21,7 +22,7 @@ const sql = postgres(process.env.DATABASE_URL, { prepare: false }) try { await installEqlV3IfNeeded(sql) - console.log('eql_v3.text_search is installed') + console.log(`eql_v3 ${releaseManifest.eqlVersion} is installed`) } finally { await sql.end() } diff --git a/packages/stack/src/adapter-kit.ts b/packages/stack/src/adapter-kit.ts new file mode 100644 index 000000000..8dcf65041 --- /dev/null +++ b/packages/stack/src/adapter-kit.ts @@ -0,0 +1,49 @@ +/** + * Internal support surface for FIRST-PARTY adapter packages + * (`@cipherstash/stack-supabase`, `@cipherstash/stack-drizzle`). + * + * These symbols were previously reached through deep `@/` internal imports while + * the Supabase and Drizzle adapters lived INSIDE this package. Splitting them into + * their own packages (see issue #627) means those imports must resolve across a + * package boundary — so exactly the symbols the adapters consume are re-exported + * here, from one narrow, versioned entry point, rather than leaking six internal + * module paths into the public surface. + * + * NOT a general-purpose public API. This is the seam between core and the + * first-party adapters; treat it as `@internal`-adjacent. Anything an END USER + * should reach has a dedicated subpath (`./schema`, `./eql/v3`, `./types`, + * `./identity`, `./errors`). If a symbol here graduates to genuine public use, + * promote it to one of those instead of widening this file's contract. + * + * The full member list is small on purpose; every addition is an audit decision. + */ + +// Model → encrypted-PG-composite helpers used by the v2 Supabase mutation path. +export { + bulkModelsToEncryptedPgComposites, + modelToEncryptedPgComposites, +} from './encryption/helpers/index.js' + +// Audit config carried by chainable operations. +export type { AuditConfig } from './encryption/operations/base-operation.js' + +// v3 column model + the date-like cast set the Supabase builder uses to +// reconstruct `Date` values from PostgREST select aliases. +export { + type AnyEncryptedV3Column, + DATE_LIKE_CASTS, + EncryptedV3Column, +} from './eql/v3/columns.js' + +// Domain registry: the Supabase adapter classifies introspected columns by their +// Postgres domain and rebuilds each column's encryption config from it. +export { + DOMAIN_REGISTRY, + factoryForDomain, + stripDomainSchema, +} from './eql/v3/domain-registry.js' + +// Shared match-index guard (short-needle rejection), reused by both adapters. +export { matchNeedleError } from './schema/match-defaults.js' +// Shared structured logger (adapters log rejections through the same instance). +export { logger } from './utils/logger/index.js' diff --git a/packages/stack/src/encryption/helpers/infer-index-type.ts b/packages/stack/src/encryption/helpers/infer-index-type.ts index 83cd0388a..8cbd4e6b6 100644 --- a/packages/stack/src/encryption/helpers/infer-index-type.ts +++ b/packages/stack/src/encryption/helpers/infer-index-type.ts @@ -9,7 +9,9 @@ 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) + * Priority: unique > match > ore/ope > ste_vec (for scalar queries; a column + * carries at most one of `ore`/`ope` — the ordering flavour is pinned by its + * EQL v3 domain). */ export function inferIndexType(column: BuildableQueryColumn): FfiIndexTypeName { const config = column.build() @@ -23,6 +25,7 @@ export function inferIndexType(column: BuildableQueryColumn): FfiIndexTypeName { if (indexes.unique) return 'unique' if (indexes.match) return 'match' if (indexes.ore) return 'ore' + if (indexes.ope) return 'ope' if (indexes.ste_vec) return 'ste_vec' throw new Error( @@ -66,6 +69,7 @@ export function validateIndexType( unique: !!indexes.unique, match: !!indexes.match, ore: !!indexes.ore, + ope: !!indexes.ope, ste_vec: !!indexes.ste_vec, } @@ -77,24 +81,32 @@ export function validateIndexType( } /** - * v3-only: an order-capable column answers EQUALITY via its `ore` (`ob`) index. + * v3-only: an order-capable column answers EQUALITY via its ordering index + * (`ope`/`op` on `_ord` domains, `ore`/`ob` on `_ord_ore` domains). * * The v3 capability contract (`src/eql/v3`) documents `equality` as "exact-match - * lookups (EQL `hm`, or comparison via `ob`)", so an order-capable column with only - * an `ore` index still supports equality — the equality-vs-range distinction is made - * by the SQL comparison operator (`=` vs `>=`), NOT by the ciphertext (the FFI emits - * the same `ob` term either way). The default `equality → unique` mapping would - * wrongly reject these columns. + * lookups (EQL `hm`, or comparison via the ordering term)", so an order-capable + * column with only an ordering index still supports equality — the + * equality-vs-range distinction is made by the SQL comparison operator (`=` vs + * `>=`), NOT by the ciphertext (the FFI emits the same ordering term either + * way). The default `equality → unique` mapping would wrongly reject these + * columns. Returns the ordering index to use, or `null` when equality does not + * resolve through one. * * Gated on `getQueryCapabilities`, which only v3 queryable columns expose — a v2 * `EncryptedColumn` lacks it and so never matches, preserving v2's * equality-without-unique throw unchanged (the no-v2-change constraint). */ -function resolvesEqualityViaOre(column: BuildableQueryColumn): boolean { - if (!('getQueryCapabilities' in column)) return false - if (!column.getQueryCapabilities().equality) return false +function equalityOrderingIndex( + column: BuildableQueryColumn, +): 'ore' | 'ope' | null { + if (!('getQueryCapabilities' in column)) return null + if (!column.getQueryCapabilities().equality) return null const indexes = column.build().indexes ?? {} - return !indexes.unique && !!indexes.ore + if (indexes.unique) return null + if (indexes.ore) return 'ore' + if (indexes.ope) return 'ope' + return null } /** @@ -113,17 +125,23 @@ export function resolveIndexType( queryType?: QueryTypeName, plaintext?: Plaintext | null, ): { indexType: FfiIndexTypeName; queryOp?: QueryOpName } { - const indexType = queryType - ? queryTypeToFfi[queryType] - : inferIndexType(column) + let indexType = queryType ? queryTypeToFfi[queryType] : inferIndexType(column) if (queryType) { - // An order-capable v3 column answers equality via its `ore` index (`ob` - // term) — the same term `orderAndRange` emits, distinguished only by the SQL - // `=` operator. Resolve to `ore` (queryOp undefined) instead of throwing on - // the missing `unique` index. v2 columns never enter here (see helper). - if (queryType === 'equality' && resolvesEqualityViaOre(column)) { - return { indexType: 'ore' } + // An order-capable v3 column answers equality via its ordering index (`op` + // or `ob`) — the same term `orderAndRange` emits, distinguished only by the + // SQL `=` operator. Resolve to that index (queryOp undefined) instead of + // throwing on the missing `unique` index. v2 columns never enter here. + if (queryType === 'equality') { + const ordering = equalityOrderingIndex(column) + if (ordering) return { indexType: ordering } + } + + // `orderAndRange` maps statically to `ore`; v3 `_ord` domains configure + // `ope` instead. Swap to the ordering index the column actually carries. + if (queryType === 'orderAndRange' && indexType === 'ore') { + const indexes = column.build().indexes ?? {} + if (!indexes.ore && indexes.ope) indexType = 'ope' } validateIndexType(column, indexType) diff --git a/packages/stack/src/encryption/helpers/model-helpers.ts b/packages/stack/src/encryption/helpers/model-helpers.ts index 1ba3997a9..1d7eec4fc 100644 --- a/packages/stack/src/encryption/helpers/model-helpers.ts +++ b/packages/stack/src/encryption/helpers/model-helpers.ts @@ -4,6 +4,7 @@ import { encryptBulk, } from '@cipherstash/protect-ffi' import { isEncryptedPayload } from '@/encryption/helpers' +import { assertValidNumericValue } from '@/encryption/helpers/validation' import type { AuditData } from '@/encryption/operations/base-operation' import type { Context } from '@/identity' import type { BuildableTable, Client, Decrypted, Encrypted } from '@/types' @@ -272,7 +273,12 @@ function prepareFieldsForEncryption>( ) } } else if (columnPaths.includes(fullKey)) { - // Only process fields that are explicitly defined in the schema + // Only process fields that are explicitly defined in the schema. + // Reject an out-of-range numeric plaintext (NaN/±Infinity for `number`, + // outside i64 for `bigint`) here — the single-value/query paths guard + // at their own boundary, but the model path builds the FFI payload + // directly, so validate per field before it reaches protect-ffi. + assertValidNumericValue(value) const id = index.toString() keyMap[id] = fullKey operationFields[fullKey] = value @@ -569,7 +575,13 @@ function prepareBulkModelsForOperation>( ) } } else if (columnPaths.includes(fullKey)) { - // Only process fields that are explicitly defined in the schema + // Only process fields that are explicitly defined in the schema. + // Reject an out-of-range numeric plaintext (NaN/±Infinity for + // `number`, outside i64 for `bigint`) before it reaches the bulk FFI + // payload — the bulk path builds that payload directly. This arm runs + // only for encryption (`if (table)`); the decrypt walker below does + // not validate. + assertValidNumericValue(value) const id = index.toString() keyMap[id] = { modelIndex, fieldKey: fullKey } modelOperationFields[fullKey] = value diff --git a/packages/stack/src/encryption/helpers/validation.ts b/packages/stack/src/encryption/helpers/validation.ts index ab4110406..b97ebb14a 100644 --- a/packages/stack/src/encryption/helpers/validation.ts +++ b/packages/stack/src/encryption/helpers/validation.ts @@ -3,7 +3,26 @@ import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import type { FfiIndexTypeName } from '@/types' /** - * Validates that a value is not NaN or Infinity. + * Inclusive bounds of a signed 64-bit integer (`int8`) — the range every + * `bigint` domain (`public.eql_v3_bigint`, `bigint_eq`, `bigint_ord_ore`, + * `bigint_ord`) maps to on the Postgres side. A `bigint` outside this range + * cannot be expressed as an `int8`, so it must be rejected before it reaches + * protect-ffi (whose behaviour on an out-of-range value is unobservable here). + * This is the `bigint` analog of the NaN/±Infinity guard for `number` domains: + * a deterministic, client-side rejection of a plaintext the target type cannot + * hold. + */ +const INT64_MIN = -9223372036854775808n +const INT64_MAX = 9223372036854775807n + +/** True when `value` is a `bigint` outside the signed 64-bit range. */ +function isBigintOutOfInt64Range(value: unknown): value is bigint { + return typeof value === 'bigint' && (value < INT64_MIN || value > INT64_MAX) +} + +/** + * Validates that a value is not NaN/Infinity and, for `bigint`, is within the + * signed 64-bit (`int8`) range. * Returns a failure Result if validation fails, undefined otherwise. * Use this in async flows that return Result types. * @@ -30,11 +49,20 @@ export function validateNumericValue( }, } } + if (isBigintOutOfInt64Range(value)) { + return { + failure: { + type: EncryptionErrorTypes.EncryptionError, + message: '[encryption]: Cannot encrypt bigint value out of int64 range', + }, + } + } return undefined } /** - * Validates that a value is not NaN or Infinity. + * Validates that a value is not NaN/Infinity and, for `bigint`, is within the + * signed 64-bit (`int8`) range. * Throws an error if validation fails. * Use this in sync flows where exceptions are caught. * @@ -47,6 +75,11 @@ export function assertValidNumericValue(value: unknown): void { if (typeof value === 'number' && !Number.isFinite(value)) { throw new Error('[encryption]: Cannot encrypt Infinity value') } + if (isBigintOutOfInt64Range(value)) { + throw new Error( + '[encryption]: Cannot encrypt bigint value out of int64 range', + ) + } } /** @@ -62,7 +95,10 @@ export function validateValueIndexCompatibility( indexType: FfiIndexTypeName, columnName: string, ): Result | undefined { - if (typeof value === 'number' && indexType === 'match') { + if ( + (typeof value === 'number' || typeof value === 'bigint') && + indexType === 'match' + ) { return { failure: { type: EncryptionErrorTypes.EncryptionError, @@ -86,7 +122,10 @@ export function assertValueIndexCompatibility( indexType: FfiIndexTypeName, columnName: string, ): void { - if (typeof value === 'number' && indexType === 'match') { + if ( + (typeof value === 'number' || typeof value === 'bigint') && + indexType === 'match' + ) { throw new Error( `[encryption]: Cannot use 'match' index with numeric value on column "${columnName}". The 'freeTextSearch' index only supports string values. Configure the column with 'orderAndRange()' or 'equality()' for numeric queries.`, ) diff --git a/packages/stack/src/encryption/operations/batch-encrypt-query.ts b/packages/stack/src/encryption/operations/batch-encrypt-query.ts index ca5cfb3ba..9b6dcb61e 100644 --- a/packages/stack/src/encryption/operations/batch-encrypt-query.ts +++ b/packages/stack/src/encryption/operations/batch-encrypt-query.ts @@ -83,17 +83,17 @@ function buildQueryPayload( */ function assembleResults( totalLength: number, - encryptedValues: ( - | CipherStashEncrypted - | CipherStashEncryptedQuery - | CipherStashEncryptedV3Query - )[], + // Typed as the FFI bulk-query return so it tracks the upstream union. As of + // protect-ffi 0.27 that union also includes `SteVecQuery`, but scalar query + // terms (all this operation builds) never produce a ste_vec result, so each + // element is narrowed back to the scalar shape `formatEncryptedResult` takes. + encryptedValues: Awaited>, nonNullTerms: { term: ScalarQueryTerm; originalIndex: number }[], ): EncryptedQueryResult[] { const results: EncryptedQueryResult[] = new Array(totalLength).fill(null) nonNullTerms.forEach(({ term, originalIndex }, i) => { results[originalIndex] = formatEncryptedResult( - encryptedValues[i], + encryptedValues[i] as CipherStashEncrypted | CipherStashEncryptedQuery, term.returnType, ) }) diff --git a/packages/stack/src/encryption/operations/bulk-encrypt.ts b/packages/stack/src/encryption/operations/bulk-encrypt.ts index 6e3ec802d..3970fea0e 100644 --- a/packages/stack/src/encryption/operations/bulk-encrypt.ts +++ b/packages/stack/src/encryption/operations/bulk-encrypt.ts @@ -1,6 +1,7 @@ import { type Result, withResult } from '@byteslice/result' import { encryptBulk, type JsPlaintext } from '@cipherstash/protect-ffi' import { getErrorCode } from '@/encryption/helpers/error-code' +import { assertValidNumericValue } from '@/encryption/helpers/validation' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import { type Context, @@ -23,6 +24,12 @@ import { EncryptionOperation } from './base-operation' // Drops nulls so they don't reach protect-ffi (which would otherwise // produce a SteVec wrapping the JSON null). The dropped positions are // re-inserted as null in `mapEncryptedDataToResult`. +// +// Each surviving plaintext is validated exactly as `EncryptOperation` validates +// its single operand: NaN / ±Infinity / out-of-int64 `bigint` are rejected +// client-side, because protect-ffi's behaviour on such a value is unobservable. +// Callers that batch instead of looping (the v3 Drizzle `inArray`, for one) +// must not lose that guard by choosing the bulk path. const createEncryptPayloads = ( plaintexts: BulkEncryptPayload, column: BuildableColumn, @@ -31,13 +38,16 @@ const createEncryptPayloads = ( ) => { return plaintexts .filter(({ plaintext }) => plaintext !== null) - .map(({ id, plaintext }) => ({ - id, - plaintext: plaintext as JsPlaintext, - column: column.getName(), - table: table.tableName, - ...(lockContext && { lockContext }), - })) + .map(({ id, plaintext }) => { + assertValidNumericValue(plaintext) + return { + id, + plaintext: plaintext as JsPlaintext, + column: column.getName(), + table: table.tableName, + ...(lockContext && { lockContext }), + } + }) } const createNullResult = (plaintexts: BulkEncryptPayload): BulkEncryptedData => diff --git a/packages/stack/src/encryption/v3.ts b/packages/stack/src/encryption/v3.ts index bdf3734c2..14d934556 100644 --- a/packages/stack/src/encryption/v3.ts +++ b/packages/stack/src/encryption/v3.ts @@ -9,7 +9,8 @@ import type { V3EncryptedModel, V3ModelInput, } from '@/eql/v3' -import type { EncryptionError } from '@/errors' +import { DATE_LIKE_CASTS } from '@/eql/v3/columns' +import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import type { LockContextInput } from '@/identity' import type { BulkDecryptPayload, @@ -18,8 +19,10 @@ import type { Encrypted, EncryptedReturnType, EncryptOptions, + ScalarQueryTerm, } from '@/types' import { + type BatchEncryptQueryOperation, type BulkDecryptOperation, type BulkEncryptModelsOperation, type BulkEncryptOperation, @@ -69,6 +72,14 @@ export interface TypedEncryptionClient { }, ): EncryptQueryOperation + /** + * Batch form: encrypt many query terms in one crossing. Mirrors the nominal + * {@link EncryptionClient} overload — the per-term columns are heterogeneous, + * so the terms are the base {@link ScalarQueryTerm} rather than a per-column + * narrowed type. Consumed by the Drizzle `inArray`/`notInArray` operators. + */ + encryptQuery(terms: readonly ScalarQueryTerm[]): BatchEncryptQueryOperation + encryptModel
>( input: V3ModelInput, table: Table, @@ -127,8 +138,10 @@ export interface TypedEncryptionClient { * row-invariant, but non-trivial to build — is derived once per call site, * not once per row on the bulk path. * - * NOTE: `bigint` reconstruction is intentionally absent — bigint domains are - * omitted from the v3 SDK until the native FFI supports lossless bigint I/O. + * NOTE: only date-like casts need per-row reconstruction. `bigint` (int8) + * needs none — protect-ffi 0.28 returns a native JS `bigint` on decrypt + * (and bounds-checks/encodes it on encrypt), so those columns pass through + * unchanged, exactly like `string`/`number`/`boolean`. */ function rowReconstructor( table: AnyV3Table, @@ -137,13 +150,13 @@ function rowReconstructor( // config keyed by DB name — bridge the two via the table's property→DB map. const { columns } = table.build() const propToDb = table.buildColumnKeyMap() - // Only date/timestamp columns need per-row work; resolve them up front. - // Both kinds decrypt to a JS `Date` — 'timestamp' additionally preserves - // the time-of-day component through the FFI. + // Only date-like columns need per-row work; resolve them up front. const dateProperties = Object.entries(propToDb) .filter(([, dbName]) => { const castAs = columns[dbName]?.cast_as - return castAs === 'date' || castAs === 'timestamp' + // Date-like casts share one source of truth with the type-level + // reconstruction (`PlaintextFromKind`) — see `DATE_LIKE_CASTS`. + return (DATE_LIKE_CASTS as readonly string[]).includes(castAs as string) }) .map(([property]) => property) @@ -169,29 +182,91 @@ function rowReconstructor( */ export function typedClient( client: EncryptionClient, - ..._schemas: S + ...schemas: S ): TypedEncryptionClient { + // Precompute one row reconstructor per schema table at construction. This runs + // each table's `build()` — which throws on duplicate DB column names — ONCE, + // here, off the Result-returning decrypt path. `decryptModel`/ + // `bulkDecryptModels` therefore never call `build()` (whose throw would surface + // as a promise rejection and break their `Promise>` contract) and no + // longer rebuild the row-invariant config on every call. + // Keyed by `tableName`, not table object identity: `AnyV3Table` is + // structurally typed, so a table re-imported from another module (or rebuilt + // after an HMR reload) satisfies `Table extends S[number]` yet is a different + // object. Identity keying would fail those valid calls. `tableName` is the + // semantic identity the FFI encrypt config and `build()` already key on. + const reconstructors = new Map< + string, + (row: Record) => Record + >() + for (const table of schemas) { + reconstructors.set(table.tableName, rowReconstructor(table)) + } + + // A table not among the schemas this client was initialized with has no + // precomputed reconstructor. Return a Result failure rather than building one + // inline, which could throw and reject the Result-shaped decrypt promise. + const unknownTableFailure: { failure: EncryptionError } = { + failure: { + type: EncryptionErrorTypes.DecryptionError, + message: + '[eql/v3]: decryptModel received a table this client was not initialized with — pass a table given to EncryptionV3/typedClient', + }, + } + + // Overloaded so the implementation is checked against BOTH forms directly — + // no whole-value cast. The two public signatures mirror the interface member; + // the hidden implementation signature is broad and forwards to the nominal + // client (which routes to the batch operation when no `opts` are supplied). + // Only the forwarded args are `as never`, exactly as the sibling wrappers + // below: one forwarding body cannot re-derive the nominal client's per-column + // signatures. + function encryptQuery< + Table extends S[number], + Col extends QueryableColumnsOf
, + QT extends QueryTypesForColumn= QueryTypesForColumn, + >( + plaintext: PlaintextForColumn, + opts: { + table: Table + column: Col + queryType?: QT + returnType?: EncryptedReturnType + }, + ): EncryptQueryOperation + function encryptQuery( + terms: readonly ScalarQueryTerm[], + ): BatchEncryptQueryOperation + function encryptQuery( + plaintextOrTerms: unknown, + opts?: unknown, + ): EncryptQueryOperation | BatchEncryptQueryOperation { + return client.encryptQuery(plaintextOrTerms as never, opts as never) + } + return { encrypt: (plaintext, opts) => client.encrypt(plaintext as never, opts as never), - encryptQuery: (plaintext, opts) => - client.encryptQuery(plaintext as never, opts as never), + encryptQuery, 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 reconstruct = reconstructors.get(table.tableName) + if (!reconstruct) return unknownTableFailure as never const op = client.decryptModel(input as never) const result = await (lockContext ? op.withLockContext(lockContext) : op) if (result.failure) return result as never - return { data: rowReconstructor(table)(result.data) } as never + return { data: reconstruct(result.data) } as never }, bulkDecryptModels: async (input, table, lockContext) => { + const reconstruct = reconstructors.get(table.tableName) + if (!reconstruct) return unknownTableFailure as never const op = client.bulkDecryptModels(input as never) const result = await (lockContext ? op.withLockContext(lockContext) : op) if (result.failure) return result as never - const reconstruct = rowReconstructor(table) return { data: result.data.map((row) => reconstruct(row as Record), @@ -209,12 +284,6 @@ export function typedClient( * counterpart to {@link Encryption}. Mirrors its config, then retypes the client * against the provided v3 `schemas`. * - * The underlying client is created with `eqlVersion: 3` (protect-ffi 0.27+), - * so `encrypt` / `encryptModel` emit EQL v3 wire payloads for the - * per-capability `eql_v3` domains. Pass an explicit `config.eqlVersion` to - * override — e.g. `2` to write v2-wire from a v3 schema set during a - * migration. - * * @example * ```typescript * import { EncryptionV3, encryptedTable, types } from "@cipherstash/stack/v3" @@ -235,12 +304,11 @@ export async function EncryptionV3< schemas: config.schemas as unknown as Parameters< typeof Encryption >[0]['schemas'], - // v3 schemas emit the EQL v3 wire format. Auto-detection in - // `Encryption` would resolve the same way (every v3 table carries the - // `buildColumnKeyMap` marker), but the version is set explicitly here - // so the contract doesn't hinge on duck-typing — while still honouring - // a caller's explicit override. - config: { ...config.config, eqlVersion: config.config?.eqlVersion ?? 3 }, + // Force the v3 EQL wire format. protect-ffi's newClient defaults to + // eqlVersion 2; a v2-mode client cannot resolve v3 concrete-type columns + // and fails every encrypt with "Cannot convert undefined or null to + // object". This is a v3-only invariant, so it overrides any user value. + config: { ...config.config, eqlVersion: 3 }, }) return typedClient(client, ...config.schemas) } diff --git a/packages/stack/src/eql/v3/columns.ts b/packages/stack/src/eql/v3/columns.ts index 34855ad3b..6647088ab 100644 --- a/packages/stack/src/eql/v3/columns.ts +++ b/packages/stack/src/eql/v3/columns.ts @@ -1,9 +1,5 @@ -import type { ColumnSchema, MatchIndexOpts } from '@/schema' -import { - type BuiltMatchIndexOpts, - cloneMatchOpts, - defaultMatchOpts, -} from '@/schema/match-defaults' +import type { ColumnSchema } from '@/schema' +import { defaultMatchOpts } from '@/schema/match-defaults' /** * The query capabilities a v3 concrete domain exposes. These are SDK-facing @@ -12,18 +8,44 @@ import { * `build()`. * * - `equality`: exact-match lookups (EQL `hm`, or comparison via `ob`). - * - `orderAndRange`: comparison / range lookups (EQL `ob`). + * - `orderAndRange`: comparison / range lookups (EQL `op`, or `ob` on `_ord_ore` domains). * - `freeTextSearch`: tokenised substring match (EQL `bf`). + * - `searchableJson`: encrypted-JSONB containment / selector lookups (EQL + * `ste_vec`). Optional and mutually exclusive with the scalar flags — a + * `public.eql_v3_json` document is queried by structure, not by scalar term. */ export type QueryCapabilities = Readonly<{ equality: boolean orderAndRange: boolean freeTextSearch: boolean + searchableJson?: boolean }> +/** + * The `cast_as` kinds whose decrypted plaintext reconstructs to a JS `Date`. + * + * SINGLE SOURCE OF TRUTH for the date-like set. Both the type-level + * {@link PlaintextFromKind} and the runtime `rowReconstructor` (encryption/v3.ts) + * derive their "reconstructs to `Date`" decision from this array, so the next + * `Date`-backed cast is added in exactly one place — never hand-synced across a + * type and a runtime guard that could silently drift. + * + * (`timestamp` reconstructs to `Date` just like `date`, but its `cast_as` tells + * the FFI not to truncate the time-of-day.) + */ +export const DATE_LIKE_CASTS = ['date', 'timestamp'] as const +/** A `cast_as` kind that reconstructs to `Date` — see {@link DATE_LIKE_CASTS}. */ +export type DateLikeCast = (typeof DATE_LIKE_CASTS)[number] + /** The plaintext (TypeScript) kind a v3 domain decrypts to. A subset of the * SDK `CastAs` enum, restricted to the scalar kinds v3 domains actually use. */ -type PlaintextKind = 'string' | 'number' | 'boolean' | 'date' | 'timestamp' +type PlaintextKind = + | 'string' + | 'number' + | 'bigint' + | 'boolean' + | 'json' + | DateLikeCast /** * The full, literal definition of a v3 domain. This is the LOAD-BEARING type: @@ -34,7 +56,7 @@ type PlaintextKind = 'string' | 'number' | 'boolean' | 'date' | 'timestamp' * a storage-only `date` column and plaintext inference would collapse. */ type V3DomainDefinition = Readonly<{ - eqlType: `eql_v3.${string}` + eqlType: `public.${string}` castAs: PlaintextKind capabilities: QueryCapabilities }> @@ -45,6 +67,7 @@ type QueryableFlag = D['capabilities'] extends { equality: false orderAndRange: false freeTextSearch: false + searchableJson?: false | undefined } ? false : true @@ -84,7 +107,7 @@ const TEXT_SEARCH = { * Recorded as metadata for future DDL / query-dialect increments; it is * intentionally absent from the emitted encrypt config. */ -export const TEXT_SEARCH_EQL_TYPE = 'eql_v3.text_search' +export const TEXT_SEARCH_EQL_TYPE = 'public.eql_v3_text_search' // Per-domain literal definitions. Each concrete column subclass is parameterised // by `typeof `; the literal `eqlType`/`castAs`/`capabilities` on each is @@ -94,218 +117,241 @@ export const TEXT_SEARCH_EQL_TYPE = 'eql_v3.text_search' // Exported for the `types` namespace factory (see ./types); they are internal // building blocks and are intentionally NOT re-exported from the public barrel. export const INTEGER = { - eqlType: 'eql_v3.integer', + eqlType: 'public.eql_v3_integer', castAs: 'number', capabilities: STORAGE_ONLY, } as const export const INTEGER_EQ = { - eqlType: 'eql_v3.integer_eq', + eqlType: 'public.eql_v3_integer_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const export const INTEGER_ORD_ORE = { - eqlType: 'eql_v3.integer_ord_ore', + eqlType: 'public.eql_v3_integer_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const INTEGER_ORD = { - eqlType: 'eql_v3.integer_ord', + eqlType: 'public.eql_v3_integer_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const SMALLINT = { - eqlType: 'eql_v3.smallint', + eqlType: 'public.eql_v3_smallint', castAs: 'number', capabilities: STORAGE_ONLY, } as const export const SMALLINT_EQ = { - eqlType: 'eql_v3.smallint_eq', + eqlType: 'public.eql_v3_smallint_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const export const SMALLINT_ORD_ORE = { - eqlType: 'eql_v3.smallint_ord_ore', + eqlType: 'public.eql_v3_smallint_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const SMALLINT_ORD = { - eqlType: 'eql_v3.smallint_ord', + eqlType: 'public.eql_v3_smallint_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const -// NOTE: bigint (int8) domains are intentionally NOT defined yet. The native -// protect-ffi build cannot round-trip a 64-bit int losslessly: a JS `bigint` -// fails JSON serialization, and a `string` is rejected for a `big_int` column -// ("Cannot convert String to BigInt"), while `number` loses precision above -// 2^53. Re-add BIGINT/BIGINT_EQ/BIGINT_ORD_ORE/BIGINT_ORD and their builders once the -// FFI accepts a lossless bigint on input and returns it on decrypt. +// bigint (int8) domains. Plaintext is a JS `bigint` (always decrypts to +// `bigint`); bounds are the full i64 range. protect-ffi round-trips an in-range +// native bigint losslessly, and values outside the signed 64-bit range are +// rejected client-side by `assertValidNumericValue` before they reach the FFI +// (`*_ord_ope` variants are out of scope — CIP-3403.) +export const BIGINT = { + eqlType: 'public.eql_v3_bigint', + castAs: 'bigint', + capabilities: STORAGE_ONLY, +} as const +export const BIGINT_EQ = { + eqlType: 'public.eql_v3_bigint_eq', + castAs: 'bigint', + capabilities: EQUALITY_ONLY, +} as const +export const BIGINT_ORD_ORE = { + eqlType: 'public.eql_v3_bigint_ord_ore', + castAs: 'bigint', + capabilities: ORDER_AND_RANGE, +} as const +export const BIGINT_ORD = { + eqlType: 'public.eql_v3_bigint_ord', + castAs: 'bigint', + capabilities: ORDER_AND_RANGE, +} as const export const DATE = { - eqlType: 'eql_v3.date', + eqlType: 'public.eql_v3_date', castAs: 'date', capabilities: STORAGE_ONLY, } as const export const DATE_EQ = { - eqlType: 'eql_v3.date_eq', + eqlType: 'public.eql_v3_date_eq', castAs: 'date', capabilities: EQUALITY_ONLY, } as const export const DATE_ORD_ORE = { - eqlType: 'eql_v3.date_ord_ore', + eqlType: 'public.eql_v3_date_ord_ore', castAs: 'date', capabilities: ORDER_AND_RANGE, } as const export const DATE_ORD = { - eqlType: 'eql_v3.date_ord', + eqlType: 'public.eql_v3_date_ord', castAs: 'date', capabilities: ORDER_AND_RANGE, } as const -// Timestamp domains cast as 'timestamp' (not 'date') so decrypt preserves the -// time-of-day component — the FFI's 'date' variant truncates to midnight. -// Both kinds decrypt to a JS `Date`. export const TIMESTAMP = { - eqlType: 'eql_v3.timestamp', + eqlType: 'public.eql_v3_timestamp', castAs: 'timestamp', capabilities: STORAGE_ONLY, } as const export const TIMESTAMP_EQ = { - eqlType: 'eql_v3.timestamp_eq', + eqlType: 'public.eql_v3_timestamp_eq', castAs: 'timestamp', capabilities: EQUALITY_ONLY, } as const export const TIMESTAMP_ORD_ORE = { - eqlType: 'eql_v3.timestamp_ord_ore', + eqlType: 'public.eql_v3_timestamp_ord_ore', castAs: 'timestamp', capabilities: ORDER_AND_RANGE, } as const export const TIMESTAMP_ORD = { - eqlType: 'eql_v3.timestamp_ord', + eqlType: 'public.eql_v3_timestamp_ord', castAs: 'timestamp', capabilities: ORDER_AND_RANGE, } as const export const NUMERIC = { - eqlType: 'eql_v3.numeric', + eqlType: 'public.eql_v3_numeric', castAs: 'number', capabilities: STORAGE_ONLY, } as const export const NUMERIC_EQ = { - eqlType: 'eql_v3.numeric_eq', + eqlType: 'public.eql_v3_numeric_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const export const NUMERIC_ORD_ORE = { - eqlType: 'eql_v3.numeric_ord_ore', + eqlType: 'public.eql_v3_numeric_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const NUMERIC_ORD = { - eqlType: 'eql_v3.numeric_ord', + eqlType: 'public.eql_v3_numeric_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const TEXT = { - eqlType: 'eql_v3.text', + eqlType: 'public.eql_v3_text', castAs: 'string', capabilities: STORAGE_ONLY, } as const export const TEXT_EQ = { - eqlType: 'eql_v3.text_eq', + eqlType: 'public.eql_v3_text_eq', castAs: 'string', capabilities: EQUALITY_ONLY, } as const export const TEXT_MATCH = { - eqlType: 'eql_v3.text_match', + eqlType: 'public.eql_v3_text_match', castAs: 'string', capabilities: MATCH_ONLY, } as const export const TEXT_ORD_ORE = { - eqlType: 'eql_v3.text_ord_ore', + eqlType: 'public.eql_v3_text_ord_ore', castAs: 'string', capabilities: ORDER_AND_RANGE, } as const export const TEXT_ORD = { - eqlType: 'eql_v3.text_ord', + eqlType: 'public.eql_v3_text_ord', castAs: 'string', capabilities: ORDER_AND_RANGE, } as const export const BOOLEAN = { - eqlType: 'eql_v3.boolean', + eqlType: 'public.eql_v3_boolean', castAs: 'boolean', capabilities: STORAGE_ONLY, } as const export const REAL = { - eqlType: 'eql_v3.real', + eqlType: 'public.eql_v3_real', castAs: 'number', capabilities: STORAGE_ONLY, } as const export const REAL_EQ = { - eqlType: 'eql_v3.real_eq', + eqlType: 'public.eql_v3_real_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const export const REAL_ORD_ORE = { - eqlType: 'eql_v3.real_ord_ore', + eqlType: 'public.eql_v3_real_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const REAL_ORD = { - eqlType: 'eql_v3.real_ord', + eqlType: 'public.eql_v3_real_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const DOUBLE = { - eqlType: 'eql_v3.double', + eqlType: 'public.eql_v3_double', castAs: 'number', capabilities: STORAGE_ONLY, } as const export const DOUBLE_EQ = { - eqlType: 'eql_v3.double_eq', + eqlType: 'public.eql_v3_double_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const export const DOUBLE_ORD_ORE = { - eqlType: 'eql_v3.double_ord_ore', + eqlType: 'public.eql_v3_double_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const DOUBLE_ORD = { - eqlType: 'eql_v3.double_ord', + eqlType: 'public.eql_v3_double_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const /** * Translate a domain's semantic {@link QueryCapabilities} (plus its plaintext - * `castAs`, which decides how equality is answered) into the concrete EQL index - * block emitted by `build()`. + * `castAs`, which decides how equality is answered, and its ordering flavour) + * into the concrete EQL index block emitted by `build()`. * * - `unique` (the `hm` HMAC index) whenever equality is answered via HMAC: * equality-only domains of ANY type, AND text order domains. Text equality is - * HMAC-based — the `eql_v3.text_ord` / `eql_v3.text_ord_ore` SQL domains + * HMAC-based — the `public.eql_v3_text_ord` / `public.eql_v3_text_ord_ore` SQL domains * REQUIRE `hm` in the stored ciphertext (their `eql_v3.eq_term` extracts it). - * - `ore` for any order/range domain (the `ob` term). For numeric/date order - * domains `ob` also answers equality (via the SQL `=` operator), so those emit - * `ore` ONLY — no `hm`. Text order domains emit BOTH `unique` and `ore`. + * - ONE ordering index for any order/range domain, selected by the domain's + * name (eql-3.0.0): plain `_ord` domains (and `text_search`) are OPE-backed — + * `ope`, the `op` CLLW-OPE term — while `_ord_ore` domains keep block-ORE — + * `ore`, the `ob` term. The two terms are not cross-comparable, and each + * domain's SQL CHECK requires exactly its own. For numeric/date order + * domains the ordering term also answers equality (via the SQL `=` + * operator), so those emit no `hm`. Text order domains emit BOTH `unique` + * and the ordering index. * - `match` (the `bf` bloom-filter index) for free-text search, deep-cloned from - * the per-call defaults so no nested object is ever shared across columns. + * the per-call defaults so no nested object is ever shared across columns, and + * emitted with `include_original: false` (see below). */ function indexesForCapabilities( capabilities: QueryCapabilities, castAs: PlaintextKind, + ordering: 'ope' | 'ore', ): ColumnSchema['indexes'] { const indexes: ColumnSchema['indexes'] = {} // Text equality is always HMAC-based, so a text order domain (`string` + // order/range) still needs `unique`; numeric/date order domains answer - // equality via `ob` and must NOT emit `unique`. + // equality via their ordering term and must NOT emit `unique`. if ( capabilities.equality && (!capabilities.orderAndRange || castAs === 'string') @@ -314,24 +360,66 @@ function indexesForCapabilities( } if (capabilities.orderAndRange) { - indexes.ore = {} + indexes[ordering] = {} } if (capabilities.freeTextSearch) { // The factory returns fresh, unaliased nested objects per call, so no // column's emitted match block ever shares state with another's. - indexes.match = defaultMatchOpts() + // + // `include_original` is overridden off the v2 builder's `true`. protect-ffi + // ignores the flag entirely (measured across 0.24 and 0.29, EQL v2 and v3: + // the emitted bloom is trigram-only either way, and a value shorter than + // `token_length` blooms to nothing regardless), so this is inert today. It + // is set to the value a substring-search domain actually wants — matching + // the zod schema's own default — so that a protect-ffi release which starts + // honouring the flag cannot silently break `contains`. + indexes.match = { ...defaultMatchOpts(), include_original: false } + } + + if (capabilities.searchableJson) { + // Encrypted-JSONB index (the protect-ffi config kind is named `ste_vec`). + // `prefix: 'enabled'` is a sentinel the table's `build()` rewrites to + // `${tableName}/${columnName}` — the same scheme v2 `searchableJson` uses — + // so each document's selectors are scoped to their column. + // + // `array_index_mode` indexes array elements by identity (`item`) and enables + // `$[*]` wildcard selectors, but deliberately drops `position`: `@>` + // containment must be a subset test (jsonb `@>` semantics), so `{roles:['x']}` + // matches any document whose `roles` array contains `x` REGARDLESS of index. + // With positional terms emitted (v2 `searchableJson`'s `'all'`), the needle + // for `x`-at-index-0 would miss a document holding `x` at index 1. + // + // `mode: 'compat'` is REQUIRED for eql-3.0.0: `public.eql_v3_json` orders the + // document's entries by the CLLW-OPE `op` term, so the index must emit `op` + // (compat) terms. `'standard'` emits v2's CLLW-ORE `oc` terms, which the v3 + // domain rejects at encrypt time. + indexes.ste_vec = { + prefix: 'enabled', + array_index_mode: { item: true, wildcard: true, position: false }, + mode: 'compat', + } } return indexes } +/** + * The ordering flavour a domain's name pins (eql-3.0.0): `_ord_ore` domains + * are block-ORE (`ore` index, `ob` term); every other ordering domain — + * `_ord` and `text_search` — is CLLW-OPE (`ope` index, `op` term). + */ +function orderingForEqlType(eqlType: string): 'ope' | 'ore' { + return eqlType.endsWith('_ord_ore') ? 'ore' : 'ope' +} + /** 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 + capabilities.freeTextSearch || + (capabilities.searchableJson ?? false) ) } @@ -377,6 +465,7 @@ export class EncryptedV3Column { indexes: indexesForCapabilities( this.definition.capabilities, this.definition.castAs, + orderingForEqlType(this.definition.eqlType), ), } } @@ -389,15 +478,15 @@ const TEXT_SEARCH_DOMAIN = { } as const /** - * Builder for an `eql_v3.text_search` column. + * Builder for a `public.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. + * match — there are no capability-enabling or tuning methods. The match index + * is always emitted with the default configuration. * * 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 + * `ope`, `match`), and the shared index-inference picks them by fixed priority + * `unique > match > ordering`. 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'`: @@ -412,49 +501,8 @@ const TEXT_SEARCH_DOMAIN = { export class EncryptedTextSearchColumn extends EncryptedV3Column< typeof TEXT_SEARCH_DOMAIN > { - private matchOpts: BuiltMatchIndexOpts - constructor(columnName: string) { super(columnName, TEXT_SEARCH_DOMAIN) - this.matchOpts = defaultMatchOpts() - } - - /** - * Tune the match index. Each provided key replaces its default; omitted - * keys keep the default. This NEVER enables a capability — match is always - * on for this type. Merge semantics mirror v2's `opts?.x ?? default`. - */ - freeTextSearch(opts?: MatchIndexOpts): this { - // A fresh defaults object per call supplies the `?? ` fallbacks, so no - // nested default object is ever shared into `this.matchOpts` by reference. - const defaults = defaultMatchOpts() - // Clone-on-write: deep-copy the nested tokenizer / token_filters when - // storing them so a caller mutating their own opts object between - // freeTextSearch(opts) and build() cannot leak into the emitted config. - this.matchOpts = cloneMatchOpts({ - tokenizer: opts?.tokenizer ?? defaults.tokenizer, - token_filters: opts?.token_filters ?? defaults.token_filters, - k: opts?.k ?? defaults.k, - m: opts?.m ?? defaults.m, - include_original: opts?.include_original ?? defaults.include_original, - }) - return this - } - - /** Emit the encrypt-config column. Byte-identical to a v2 equality+order+match column. */ - override build(): ColumnSchema { - // Deep-clone the match block so the returned config NEVER aliases this - // builder's internal `matchOpts` (or any caller-supplied opts merged into - // it). A caller mutating the returned object cannot corrupt this builder's - // state or another column's defaults. - return { - cast_as: 'string', - indexes: { - unique: { token_filters: [] }, - ore: {}, - match: cloneMatchOpts(this.matchOpts), - }, - } } } @@ -494,9 +542,18 @@ export class EncryptedSmallintOrdColumn extends EncryptedV3Column< typeof SMALLINT_ORD > {} -// bigint (int8) domain builders are intentionally omitted pending FFI support -// for lossless bigint round-tripping — see the note by the INTEGER/DATE domain -// definitions above. +// bigint (int8) — plaintext is a JS `bigint`, round-tripped losslessly by the +// native protect-ffi boundary (see the BIGINT domain definitions above). +export class EncryptedBigintColumn extends EncryptedV3Column {} +export class EncryptedBigintEqColumn extends EncryptedV3Column< + typeof BIGINT_EQ +> {} +export class EncryptedBigintOrdOreColumn extends EncryptedV3Column< + typeof BIGINT_ORD_ORE +> {} +export class EncryptedBigintOrdColumn extends EncryptedV3Column< + typeof BIGINT_ORD +> {} // date export class EncryptedDateColumn extends EncryptedV3Column {} @@ -572,6 +629,31 @@ export class EncryptedDoubleOrdColumn extends EncryptedV3Column< typeof DOUBLE_ORD > {} +// json +const JSON_DOMAIN = { + eqlType: 'public.eql_v3_json', + castAs: 'json', + capabilities: { + equality: false, + orderAndRange: false, + freeTextSearch: false, + searchableJson: true, + }, +} as const + +/** + * Builder for a `public.eql_v3_json` column — an encrypted JSONB document + * (a {@link JsonDocument}: object, array, or null). It round-trips through + * `encrypt`/`decrypt`, and containment queries use the encrypted-JSONB index + * emitted by `build()`. (The stored payload is protect-ffi's `SteVecDocument`, + * and the config index kind is `ste_vec` — both protect-ffi names.) + */ +export class EncryptedJsonColumn extends EncryptedV3Column { + constructor(columnName: string) { + super(columnName, JSON_DOMAIN) + } +} + /** * Union of every v3 concrete column type. Used as the value type for v3 table * columns so a table may mix any generated domains. @@ -585,6 +667,10 @@ export type AnyEncryptedV3Column = | EncryptedSmallintEqColumn | EncryptedSmallintOrdOreColumn | EncryptedSmallintOrdColumn + | EncryptedBigintColumn + | EncryptedBigintEqColumn + | EncryptedBigintOrdOreColumn + | EncryptedBigintOrdColumn | EncryptedDateColumn | EncryptedDateEqColumn | EncryptedDateOrdOreColumn @@ -612,6 +698,16 @@ export type AnyEncryptedV3Column = | EncryptedDoubleEqColumn | EncryptedDoubleOrdOreColumn | EncryptedDoubleOrdColumn + | EncryptedJsonColumn + +/** + * A factory that builds a concrete v3 column for a given DB column name. + * + * Declared here rather than beside `DOMAIN_REGISTRY` so that `./types` can + * constrain its own export against it without importing from `./domain-registry`, + * which imports `./types` back as a value. + */ +export type V3ColumnFactory = (name: string) => AnyEncryptedV3Column /** * Shape of v3 table columns: every value is a v3 concrete column builder. @@ -621,16 +717,39 @@ export type EncryptedV3TableColumn = { [key: string]: AnyEncryptedV3Column } +/** A JSON value at any depth. Used for the values NESTED inside a document. */ +export type JsonValue = + | string + | number + | boolean + | null + | JsonValue[] + | { [key: string]: JsonValue } + +/** + * The plaintext a `public.eql_v3_json` column encrypts and reconstructs: a JSON + * DOCUMENT — an object, an array, or `null`. NOT a bare top-level scalar: + * protect-ffi's `json` cast rejects a top-level string/number/boolean + * ("Cannot convert … to Json"), because a scalar belongs in a scalar domain + * (`types.TextEq`, `types.IntegerEq`, …). Nested scalars are ordinary + * {@link JsonValue}s and are fully supported. + */ +export type JsonDocument = null | JsonValue[] | { [key: string]: JsonValue } + /** Map a domain's {@link PlaintextKind} to its TypeScript plaintext type. */ type PlaintextFromKind = K extends 'string' ? string : K extends 'number' ? number - : K extends 'boolean' - ? boolean - : K extends 'date' | 'timestamp' - ? Date - : never + : K extends 'bigint' + ? bigint + : K extends 'boolean' + ? boolean + : K extends DateLikeCast + ? Date + : K extends 'json' + ? JsonDocument + : never /** * The plaintext type for a single v3 column, read from the literal domain diff --git a/packages/stack/src/eql/v3/domain-registry.ts b/packages/stack/src/eql/v3/domain-registry.ts new file mode 100644 index 000000000..6c255b1ab --- /dev/null +++ b/packages/stack/src/eql/v3/domain-registry.ts @@ -0,0 +1,71 @@ +import type { V3ColumnFactory } from './columns' +import { types } from './types' + +export type { V3ColumnFactory } from './columns' + +/** + * Unqualified Postgres `domain_name` → the `eql/v3/types.ts` factory that + * builds that domain's column. + * + * DERIVED, not hand-listed. Every factory already carries its domain in the + * constant it passes to the column constructor, so the key is recoverable from + * the factory itself — and `types` and this registry cannot drift. Adding a + * domain to `types` is enough; forgetting an entry here is no longer possible. + * + * The keys are an external contract (they are the `information_schema` query + * parameter in `../../supabase/introspect.ts`). Because they are derived from + * `getEqlType()`, no test that also derives them can detect a corrupted domain + * constant — `eql-v3-domain-registry.test.ts` pins them against a hand-written + * literal list for exactly that reason. + * + * `factory('_probe')` runs at module load, so a non-factory value in `types` + * would throw here and take the importing modules (`../../supabase/introspect.ts`, + * `schema-builder.ts`, `verify.ts`) down with it. `types` is declared + * `satisfies Record` so that mistake is a compile error + * at its source instead. Do not reintroduce a cast on `Object.values` below: it + * would silence exactly the check that keeps this loop total. + */ +// NULL PROTOTYPE — load-bearing. A plain object literal inherits from +// Object.prototype, so `DOMAIN_REGISTRY['constructor']` returns a *function* +// and passes a truthiness check. A column whose domain is named `constructor`, +// `toString`, `valueOf` or `__proto__` would then be treated as a modelled EQL +// domain and "synthesized" from Object.prototype.constructor. `factoryForDomain` +// additionally guards with `Object.hasOwn`; both are kept — belt and braces, +// because a future refactor that drops the null prototype must not silently +// reopen the hole. It also makes the `Object.hasOwn` collision check below +// exact: on a plain object `'constructor' in registry` is spuriously true. +export const DOMAIN_REGISTRY: Record = (() => { + const registry = Object.create(null) as Record + for (const factory of Object.values(types)) { + // Probe name only: the constructors store their arguments and nothing else, + // so building one column per domain at module load is free of side effects. + const key = stripDomainSchema(factory('_probe').getEqlType()) + if (Object.hasOwn(registry, key)) { + throw new Error(`duplicate EQL v3 domain key: ${key}`) + } + registry[key] = factory + } + return registry +})() + +/** Strip a leading `public.` schema qualifier from a qualified `eqlType`. */ +export function stripDomainSchema(eqlType: string): string { + return eqlType.startsWith('public.') + ? eqlType.slice('public.'.length) + : eqlType +} + +/** + * Look up the factory for an unqualified domain name, or `undefined`. + * + * `Object.hasOwn` is required, not decorative: without it a domain named + * `constructor` / `toString` / `valueOf` / `__proto__` resolves to an inherited + * `Object.prototype` member and violates the "unknown domain = plaintext" rule. + */ +export function factoryForDomain( + domainName: string, +): V3ColumnFactory | undefined { + return Object.hasOwn(DOMAIN_REGISTRY, domainName) + ? DOMAIN_REGISTRY[domainName] + : undefined +} diff --git a/packages/stack/src/eql/v3/index.ts b/packages/stack/src/eql/v3/index.ts index 3889f1f20..620132926 100644 --- a/packages/stack/src/eql/v3/index.ts +++ b/packages/stack/src/eql/v3/index.ts @@ -12,37 +12,44 @@ export type { AnyEncryptedV3Column, EncryptedV3TableColumn, EqlTypeForColumn, + JsonDocument, + JsonValue, PlaintextForColumn, QueryCapabilities, QueryTypesForColumn, } from './columns' export { + EncryptedBigintColumn, + EncryptedBigintEqColumn, + EncryptedBigintOrdColumn, + EncryptedBigintOrdOreColumn, EncryptedBooleanColumn, EncryptedDateColumn, EncryptedDateEqColumn, EncryptedDateOrdColumn, EncryptedDateOrdOreColumn, - EncryptedRealColumn, - EncryptedRealEqColumn, - EncryptedRealOrdColumn, - EncryptedRealOrdOreColumn, EncryptedDoubleColumn, EncryptedDoubleEqColumn, EncryptedDoubleOrdColumn, EncryptedDoubleOrdOreColumn, - EncryptedSmallintColumn, - EncryptedSmallintEqColumn, - EncryptedSmallintOrdColumn, - EncryptedSmallintOrdOreColumn, EncryptedIntegerColumn, EncryptedIntegerEqColumn, EncryptedIntegerOrdColumn, EncryptedIntegerOrdOreColumn, + EncryptedJsonColumn, EncryptedNumericColumn, EncryptedNumericEqColumn, EncryptedNumericOrdColumn, EncryptedNumericOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, EncryptedTextColumn, EncryptedTextEqColumn, EncryptedTextMatchColumn, diff --git a/packages/stack/src/eql/v3/table.ts b/packages/stack/src/eql/v3/table.ts index c5b3f0695..467249250 100644 --- a/packages/stack/src/eql/v3/table.ts +++ b/packages/stack/src/eql/v3/table.ts @@ -25,7 +25,14 @@ export class EncryptedTable { ) {} build(): TableDefinition { - const builtColumns: Record = {} + // NULL PROTOTYPE — load-bearing, for the same reason as + // {@link buildColumnKeyMap}. Keys are DB column names, which the database + // supplies. On a plain object literal, `builtColumns['__proto__'] = schema` + // REPARENTS the object rather than adding an own key, so the column never + // reaches the encrypt config — `decryptModel` then skips it and its + // ciphertext is returned undecrypted. `encryptedTable()` rejects such names + // as JS properties, but nothing constrains a table's DB column names. + const builtColumns: Record = Object.create(null) 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()`, @@ -56,9 +63,19 @@ export class EncryptedTable { * 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. + * + * NULL PROTOTYPE — load-bearing. Callers index this map by a column name that + * ultimately comes from the database (`addJsonbCastsV3`, `filterColumnName`, + * the mutation transform). On a plain object literal, a column named + * `constructor` / `toString` / `valueOf` / `__proto__` resolves to an + * inherited `Object.prototype` member, which is truthy — so a *plaintext* + * column with such a name would be mistaken for a mapped encrypted column and + * its `Object.prototype` value interpolated into the emitted select string. + * `encryptedTable()` rejects such names as JS *properties*, but nothing + * constrains the DB column names a table may contain. */ buildColumnKeyMap(): Record { - const map: Record = {} + const map = Object.create(null) as Record for (const [property, builder] of Object.entries(this.columnBuilders)) { map[property] = builder.getName() } @@ -211,11 +228,14 @@ export type V3EncryptedModel
= { : T[K] } -/** The decrypted result model: schema columns become their plaintext type, others pass through. */ -export type V3DecryptedModel
= { - [K in keyof T]: K extends keyof InferPlaintext
- ? null extends T[K] - ? InferPlaintext
[K] | null - : InferPlaintext
[K] - : T[K] -} +/** + * The decrypted result model: schema columns become their plaintext type, others + * pass through. Structurally identical to {@link V3ModelInput} — decrypt yields + * the same plaintext shape encrypt accepts — so it is aliased rather than + * re-declared to keep the input and output shapes from silently drifting when + * one copy is edited. The distinct name is kept for call-site readability. + */ +export type V3DecryptedModel
= V3ModelInput< + Table, + T +> diff --git a/packages/stack/src/eql/v3/types.ts b/packages/stack/src/eql/v3/types.ts index df2d55e42..f14def386 100644 --- a/packages/stack/src/eql/v3/types.ts +++ b/packages/stack/src/eql/v3/types.ts @@ -1,34 +1,47 @@ import { + BIGINT, + BIGINT_EQ, + BIGINT_ORD, + BIGINT_ORD_ORE, BOOLEAN, DATE, DATE_EQ, DATE_ORD, DATE_ORD_ORE, + DOUBLE, + DOUBLE_EQ, + DOUBLE_ORD, + DOUBLE_ORD_ORE, + EncryptedBigintColumn, + EncryptedBigintEqColumn, + EncryptedBigintOrdColumn, + EncryptedBigintOrdOreColumn, EncryptedBooleanColumn, EncryptedDateColumn, EncryptedDateEqColumn, EncryptedDateOrdColumn, EncryptedDateOrdOreColumn, - EncryptedRealColumn, - EncryptedRealEqColumn, - EncryptedRealOrdColumn, - EncryptedRealOrdOreColumn, EncryptedDoubleColumn, EncryptedDoubleEqColumn, EncryptedDoubleOrdColumn, EncryptedDoubleOrdOreColumn, - EncryptedSmallintColumn, - EncryptedSmallintEqColumn, - EncryptedSmallintOrdColumn, - EncryptedSmallintOrdOreColumn, EncryptedIntegerColumn, EncryptedIntegerEqColumn, EncryptedIntegerOrdColumn, EncryptedIntegerOrdOreColumn, + EncryptedJsonColumn, EncryptedNumericColumn, EncryptedNumericEqColumn, EncryptedNumericOrdColumn, EncryptedNumericOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, EncryptedTextColumn, EncryptedTextEqColumn, EncryptedTextMatchColumn, @@ -39,18 +52,6 @@ import { EncryptedTimestampEqColumn, EncryptedTimestampOrdColumn, EncryptedTimestampOrdOreColumn, - REAL, - REAL_EQ, - REAL_ORD, - REAL_ORD_ORE, - DOUBLE, - DOUBLE_EQ, - DOUBLE_ORD, - DOUBLE_ORD_ORE, - SMALLINT, - SMALLINT_EQ, - SMALLINT_ORD, - SMALLINT_ORD_ORE, INTEGER, INTEGER_EQ, INTEGER_ORD, @@ -59,6 +60,14 @@ import { NUMERIC_EQ, NUMERIC_ORD, NUMERIC_ORD_ORE, + REAL, + REAL_EQ, + REAL_ORD, + REAL_ORD_ORE, + SMALLINT, + SMALLINT_EQ, + SMALLINT_ORD, + SMALLINT_ORD_ORE, TEXT, TEXT_EQ, TEXT_MATCH, @@ -68,14 +77,19 @@ import { TIMESTAMP_EQ, TIMESTAMP_ORD, TIMESTAMP_ORD_ORE, + type V3ColumnFactory, } from './columns' /** - * The v3 column-type namespace. Each member is a factory that builds a concrete - * EQL v3 column; the member name mirrors the underlying `eql_v3.` domain - * (strip the `eql_v3.` prefix, PascalCase each `_`-separated segment). So - * `types.TextEq('actor')` builds an `eql_v3.text_eq` column, `types.IntegerOrd` - * an `eql_v3.integer_ord`, `types.Timestamp` an `eql_v3.timestamp`, and so on. + * The v3 column-type namespace. Each member is a public, semantic factory name + * for a concrete EQL v3 column. Most members mirror the underlying domain name; + * JS-friendly scalar names map to Postgres concrete domains, e.g. + * `types.IntegerOrd` builds a `public.eql_v3_integer_ord` column and `types.Boolean` + * builds a `public.eql_v3_boolean` column. + * + * If these factory names stop matching the emitted capability/domain surface, + * the stack package is out of sync with the underlying EQL build. That is a + * version mismatch, not a harmless naming drift. * * Each factory returns the CONCRETE column class instance (never the widened * `AnyEncryptedV3Column`) so per-column plaintext / query-capability inference @@ -91,10 +105,10 @@ import { * }) * ``` * - * `types.TextSearch` keeps the chainable `.freeTextSearch(opts)` tuner (the - * only capability-bearing chain — every other domain is fully described by its - * type). bigint domains are intentionally absent pending lossless FFI - * round-tripping (see ./columns). + * `types.TextSearch` is fully described by its type — like every other domain, + * it has no capability-bearing or tuning chain. Its match index is always + * emitted with the default configuration; run a free-text query by passing + * `queryType: 'freeTextSearch'` to `encryptQuery`. */ export const types = { // integer @@ -114,6 +128,14 @@ export const types = { SmallintOrd: (name: string) => new EncryptedSmallintOrdColumn(name, SMALLINT_ORD), + // bigint (int8) — plaintext is a JS `bigint`, round-tripped losslessly by + // the native protect-ffi boundary (see ./columns) + Bigint: (name: string) => new EncryptedBigintColumn(name, BIGINT), + BigintEq: (name: string) => new EncryptedBigintEqColumn(name, BIGINT_EQ), + BigintOrdOre: (name: string) => + new EncryptedBigintOrdOreColumn(name, BIGINT_ORD_ORE), + BigintOrd: (name: string) => new EncryptedBigintOrdColumn(name, BIGINT_ORD), + // date Date: (name: string) => new EncryptedDateColumn(name, DATE), DateEq: (name: string) => new EncryptedDateEqColumn(name, DATE_EQ), @@ -163,4 +185,12 @@ export const types = { DoubleOrdOre: (name: string) => new EncryptedDoubleOrdOreColumn(name, DOUBLE_ORD_ORE), DoubleOrd: (name: string) => new EncryptedDoubleOrdColumn(name, DOUBLE_ORD), -} as const + + // json (encrypted JSONB document, ste_vec containment) + Json: (name: string) => new EncryptedJsonColumn(name), + // `satisfies` is load-bearing, not decoration: `DOMAIN_REGISTRY` derives itself + // by calling every value here at module load. A non-factory export would throw + // during module evaluation and take the supabase introspect/schema-build/verify + // path down with it. This turns that into a compile error at the offending line. + // `as const` applies first, so literal key inference is preserved. +} as const satisfies Record diff --git a/packages/stack/src/schema/index.ts b/packages/stack/src/schema/index.ts index 2b2842a91..7c68bf649 100644 --- a/packages/stack/src/schema/index.ts +++ b/packages/stack/src/schema/index.ts @@ -1,6 +1,6 @@ import { z } from 'zod' import type { BuildableTable, Encrypted } from '@/types' -import { defaultMatchOpts } from './match-defaults' +import { resolveMatchOpts } from './match-defaults' // ------------------------ // Zod schemas @@ -46,6 +46,10 @@ export const eqlCastAsEnum = z /** * SDK-facing data types — developer-friendly aliases accepted by `dataType()`. + * + * `timestamp` is distinct from `date`: `date` is calendar-date only (time-of-day + * truncated to midnight), while `timestamp` preserves the full date+time. v3 + * `timestamp` domains set `cast_as: 'timestamp'` so the FFI keeps the instant. */ export const castAsEnum = z .enum([ @@ -106,6 +110,11 @@ const tokenizerSchema = z const oreIndexOptsSchema = z.object({}) +// The OPE (CLLW-OPE, `op` term) ordering index — protect-ffi 0.29+. Emitted by +// the EQL v3 `_ord` domains; the `_ord_ore` domains keep `ore` (block-ORE, +// `ob`). v2 columns never emit it. +const opeIndexOptsSchema = z.object({}) + const uniqueIndexOptsSchema = z.object({ token_filters: z.array(tokenFilterSchema).default([]).optional(), }) @@ -131,11 +140,13 @@ const arrayIndexModeSchema = z.union([ const steVecIndexOptsSchema = z.object({ prefix: z.string(), array_index_mode: arrayIndexModeSchema.optional(), + mode: z.enum(['compat', 'standard']).optional(), }) const indexesSchema = z .object({ ore: oreIndexOptsSchema.optional(), + ope: opeIndexOptsSchema.optional(), unique: uniqueIndexOptsSchema.optional(), match: matchIndexOptsSchema.optional(), ste_vec: steVecIndexOptsSchema.optional(), @@ -176,6 +187,7 @@ export type MatchIndexOpts = z.infer export type SteVecIndexOpts = z.infer export type UniqueIndexOpts = z.infer export type OreIndexOpts = z.infer +export type OpeIndexOpts = z.infer export type ColumnSchema = z.infer /** @@ -224,7 +236,7 @@ export class EncryptedField { * a different type so the encryption layer knows how to encode the plaintext * before encrypting. * - * @param castAs - The plaintext data type: `'string'`, `'number'`, `'boolean'`, `'date'`, `'text'`, `'bigint'`, or `'json'`. + * @param castAs - The plaintext data type: `'string'`, `'number'`, `'boolean'`, `'date'`, `'timestamp'`, `'text'`, `'bigint'`, or `'json'`. Use `'timestamp'` (not `'date'`) to preserve time-of-day — `'date'` truncates to midnight. * @returns This `EncryptedField` instance for method chaining. * * @example @@ -256,6 +268,9 @@ export class EncryptedColumn { private castAsValue: CastAs private indexesValue: { ore?: OreIndexOpts + // Never set by the v2 fluent builder (the OPE index is EQL v3-only); + // declared so `build()` stays assignable to the shared indexes shape. + ope?: OpeIndexOpts unique?: UniqueIndexOpts match?: Required ste_vec?: SteVecIndexOpts @@ -273,7 +288,7 @@ export class EncryptedColumn { * a different type so the encryption layer knows how to encode the plaintext * before encrypting. * - * @param castAs - The plaintext data type: `'string'`, `'number'`, `'boolean'`, `'date'`, `'bigint'`, or `'json'`. + * @param castAs - The plaintext data type: `'string'`, `'number'`, `'boolean'`, `'date'`, `'timestamp'`, `'text'`, `'bigint'`, or `'json'`. Use `'timestamp'` (not `'date'`) to preserve time-of-day — `'date'` truncates to midnight. * @returns This `EncryptedColumn` instance for method chaining. * * @example @@ -365,16 +380,11 @@ export class EncryptedColumn { * ``` */ freeTextSearch(opts?: MatchIndexOpts) { - // Shared defaults (schema/match-defaults) — one source of truth with the - // EQL v3 domain builders. The factory returns fresh nested objects. - const defaults = defaultMatchOpts() - this.indexesValue.match = { - tokenizer: opts?.tokenizer ?? 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, - } + // Shared merge+clone (schema/match-defaults) — one source of truth with the + // EQL v3 domain builders. `resolveMatchOpts` deep-clones, so a caller + // mutating their own `opts` (or its nested tokenizer/token_filters) after + // this call cannot leak into the stored schema. + this.indexesValue.match = resolveMatchOpts(opts) return this } @@ -402,7 +412,17 @@ export class EncryptedColumn { */ searchableJson() { this.castAsValue = 'json' - this.indexesValue.ste_vec = { prefix: 'enabled', array_index_mode: 'all' } + // `mode: 'standard'` pins the per-entry ordering term to CLLW-ORE (`oc`), + // the only encoding the eql_v2 SQL compares. protect-ffi 0.29 flipped the + // library default to `compat` (CLLW-OPE, `op`) for EQL v3; without the pin + // every v2 containment query silently matches nothing — and existing v2 + // rows encrypted under `standard` are not cross-comparable with `compat` + // anyway, so this also keeps the v2 wire format byte-stable. + this.indexesValue.ste_vec = { + prefix: 'enabled', + array_index_mode: 'all', + mode: 'standard', + } return this } diff --git a/packages/stack/src/schema/match-defaults.ts b/packages/stack/src/schema/match-defaults.ts index e1a4090bb..45fd5232f 100644 --- a/packages/stack/src/schema/match-defaults.ts +++ b/packages/stack/src/schema/match-defaults.ts @@ -20,9 +20,18 @@ export type BuiltMatchIndexOpts = { /** * Default match-index parameters — the single source of truth shared by the - * v2 `freeTextSearch()` builder and the v3 domain builders (note - * `include_original: true`, which is the v2 builder default rather than the - * zod-schema default of `false`). + * v2 `freeTextSearch()` builder and the v3 domain builders. + * + * `include_original: true` is the v2 builder's historical default rather than + * the zod-schema default of `false`. It is INERT: protect-ffi accepts the flag + * and ignores it (measured across 0.24 and 0.29, EQL v2 and v3 — the emitted + * bloom is trigram-only either way). It is kept here only so the v2 emitted + * config does not move. The v3 domain builders override it to `false`, the + * value a substring-search domain wants if ffi ever starts honouring it. + * + * In particular it does NOT let a value shorter than the tokenizer's + * `token_length` be matched: such a value blooms to nothing under either + * setting, which is exactly the fail-open {@link matchNeedleError} guards. * * This is a FACTORY (not a shared `const`) so every caller gets fresh, unaliased * nested objects (`tokenizer`, `token_filters` and the `{ kind: 'downcase' }` @@ -52,3 +61,86 @@ export function cloneMatchOpts(opts: BuiltMatchIndexOpts): BuiltMatchIndexOpts { token_filters: opts.token_filters.map((f) => ({ ...f })), } } + +/** + * Resolve user-supplied `freeTextSearch(opts)` input into a fully-built match + * block: each provided key replaces its default, omitted keys keep the default + * (`opts?.x ?? default.x`). The single source of truth for that five-field merge + * shared by the v2 `freeTextSearch()` builder and the v3 domain builders. + * + * The result is deep-cloned ({@link cloneMatchOpts}) so a caller mutating their + * own `opts` object (or its nested `tokenizer`/`token_filters`) after this call + * can never leak into the stored builder state or the emitted config — clone-on- + * write for both builders, not just v3. + */ +export function resolveMatchOpts(opts?: MatchIndexOpts): BuiltMatchIndexOpts { + const defaults = defaultMatchOpts() + return cloneMatchOpts({ + tokenizer: opts?.tokenizer ?? defaults.tokenizer, + token_filters: opts?.token_filters ?? defaults.token_filters, + k: opts?.k ?? defaults.k, + m: opts?.m ?? defaults.m, + include_original: opts?.include_original ?? defaults.include_original, + }) +} + +/** + * The shortest needle a match index can answer, or `undefined` when its + * tokenizer imposes no floor (`standard` splits on word boundaries, so any + * non-empty needle yields at least one token). + * + * Accepts the loose {@link MatchIndexOpts} because a `ColumnSchema`'s built + * `indexes.match` is typed from the zod schema, where `tokenizer` is optional. + * An absent tokenizer resolves to the same default the schema itself applies + * (`ngram`, `token_length: 3`) rather than skipping the floor — skipping would + * reintroduce the fail-open this guard exists to close. + */ +export function matchNeedleMinLength(opts: MatchIndexOpts): number | undefined { + const tokenizer = opts.tokenizer ?? defaultMatchOpts().tokenizer + return tokenizer.kind === 'ngram' ? tokenizer.token_length : undefined +} + +/** + * Why a needle cannot be answered by this match index, or `undefined` when it + * can. Callers throw their own error type with this as the reason. + * + * A needle that tokenizes to NOTHING has an empty bloom filter, and + * `stored_bf @> '{}'` is true for every row ("contains nothing, contained by + * everything"). Such a query is unanswerable rather than merely unmatched, so + * it must fail loudly instead of silently returning the whole table. Two ways + * to tokenize to nothing: + * + * - the empty needle, under ANY tokenizer; + * - a needle shorter than the ngram tokenizer's `token_length`. + * + * The ngram floor counts Unicode CODEPOINTS, because that is what the tokenizer + * counts. `needle.length` would count UTF-16 code units and wave through an + * astral-plane needle: `'👍👍'` is 4 code units but only 2 codepoints, yields no + * trigram, and (measured live) matched every row. Graphemes are the wrong unit + * in the other direction — NFD `'éé'` is 4 codepoints but 2 grapheme clusters, + * and does yield trigrams. + * + * Currently wired ONLY into the v3 Drizzle adapter (`eql/v3/drizzle/operators`). + * It lives here, beside the shared match defaults, because v2 builds the same + * bloom filters and needs the same floor — but v2's `like`/`ilike` path remains + * unguarded and still fails open. Do not reuse this for v2 without first + * measuring what its tokenizer actually receives: v2 needles carry SQL wildcards + * (`'%ada%'`), so the floor may have to apply to the unwrapped term rather than + * to the string the caller passed. + */ +export function matchNeedleError( + needle: unknown, + opts: MatchIndexOpts, +): string | undefined { + if (typeof needle !== 'string') return undefined + + // Codepoints, not UTF-16 code units — see above. + const length = [...needle].length + const min = matchNeedleMinLength(opts) + + if (length === 0) { + return `free-text search needs a non-empty search term; an empty term produces no tokens and would match every row.` + } + if (min === undefined || length >= min) return undefined + return `free-text search needs at least ${min} characters (the index tokenizer's token_length), but the search term ${JSON.stringify(needle)} has ${length}. A shorter term produces no tokens and would match every row.` +} diff --git a/packages/stack/src/supabase/helpers.ts b/packages/stack/src/supabase/helpers.ts deleted file mode 100644 index 5f9c2070e..000000000 --- a/packages/stack/src/supabase/helpers.ts +++ /dev/null @@ -1,299 +0,0 @@ -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' -import type { QueryTypeName } from '@/types' -import type { FilterOp, PendingOrCondition } from './types' - -/** - * Get the names of all encrypted columns defined in a table schema. - */ -export function getEncryptedColumnNames( - schema: EncryptedTable, -): string[] { - const built = schema.build() - return Object.keys(built.columns) -} - -/** - * Check whether a column name refers to an encrypted column in the schema. - */ -export function isEncryptedColumn( - columnName: string, - encryptedColumnNames: string[], -): boolean { - return encryptedColumnNames.includes(columnName) -} - -/** - * Parse a Supabase select string and add `::jsonb` casts to encrypted columns. - * - * Input: `'id, email, name'` - * Output: `'id, email::jsonb, name::jsonb'` (if email and name are encrypted) - * - * Handles whitespace, already-cast columns, and embedded functions. - */ -export function addJsonbCasts( - columns: string, - encryptedColumnNames: string[], -): string { - return columns - .split(',') - .map((col) => { - const trimmed = col.trim() - - // Skip empty segments - if (!trimmed) return col - - // If it already has a cast (e.g. `email::jsonb`), skip - if (trimmed.includes('::')) return col - - // If it contains parens (function call) or dots (foreign table), skip - if (trimmed.includes('(') || trimmed.includes('.')) return col - - // Check if the column name (possibly with alias) is encrypted - // Handle `column_name` or `column_name as alias` - const parts = trimmed.split(/\s+/) - const colName = parts[0] - - if (isEncryptedColumn(colName, encryptedColumnNames)) { - // Preserve original whitespace before the column - const leadingWhitespace = col.match(/^(\s*)/)?.[1] ?? '' - if (parts.length > 1) { - // Has alias: `email as e` -> `email::jsonb as e` - return `${leadingWhitespace}${colName}::jsonb ${parts.slice(1).join(' ')}` - } - return `${leadingWhitespace}${colName}::jsonb` - } - - return col - }) - .join(',') -} - -/** - * Parse a Supabase select string and add `::jsonb` casts to encrypted EQL v3 - * columns, resolving JS property names to DB column names via PostgREST - * aliasing. - * - * Input: `'id, email, createdAt'` with `{ email: 'email', createdAt: 'created_at' }` - * Output: `'id, email::jsonb, createdAt:created_at::jsonb'` - * - * - A property whose DB name differs is emitted as `prop:db_name::jsonb` - * (PostgREST rename syntax), so result rows come back keyed by the JS - * property name. - * - A DB column name used directly is cast in place (`db_name::jsonb`). - * - Tokens that already carry a cast, or contain parens/dots (functions, - * foreign tables), are left untouched — same rules as the v2 helper. - * - * Besides the rewritten select string, returns `keyToDb`: every result-row - * key this select produces for an encrypted column, mapped to its DB column - * name — including user-chosen PostgREST aliases (`ts:created_at` → rows - * keyed `ts`). The v3 builder uses it to reconstruct `Date` values on keys - * the static property↔DB map cannot see. - */ -export function addJsonbCastsV3( - columns: string, - propToDb: Record, -): { select: string; keyToDb: Record } { - const dbNames = new Set(Object.values(propToDb)) - const keyToDb: Record = {} - - const select = columns - .split(',') - .map((col) => { - const trimmed = col.trim() - - if (!trimmed) return col - if (trimmed.includes('::')) return col - if (trimmed.includes('(') || trimmed.includes('.')) return col - - const leadingWhitespace = col.match(/^(\s*)/)?.[1] ?? '' - - // Already-aliased token: `alias:column` - const aliasMatch = trimmed.match( - /^([A-Za-z_][A-Za-z0-9_]*):([A-Za-z_][A-Za-z0-9_]*)$/, - ) - if (aliasMatch) { - const [, alias, name] = aliasMatch - const db = propToDb[name] ?? (dbNames.has(name) ? name : undefined) - if (db !== undefined) { - keyToDb[alias] = db - return `${leadingWhitespace}${alias}:${db}::jsonb` - } - return col - } - - const db = propToDb[trimmed] - if (db !== undefined) { - keyToDb[trimmed] = db - return db === trimmed - ? `${leadingWhitespace}${trimmed}::jsonb` - : `${leadingWhitespace}${trimmed}:${db}::jsonb` - } - - if (dbNames.has(trimmed)) { - keyToDb[trimmed] = trimmed - return `${leadingWhitespace}${trimmed}::jsonb` - } - - return col - }) - .join(',') - - return { select, keyToDb } -} - -/** - * Map a Supabase filter operation to a CipherStash query type. - */ -export function mapFilterOpToQueryType(op: FilterOp): QueryTypeName { - switch (op) { - case 'eq': - case 'neq': - case 'in': - case 'is': - return 'equality' - case 'like': - case 'ilike': - return 'freeTextSearch' - case 'gt': - case 'gte': - case 'lt': - case 'lte': - return 'orderAndRange' - default: - return 'equality' - } -} - -/** - * Parse a Supabase `.or()` filter string into structured conditions. - * - * Input: `'email.eq.john@example.com,name.ilike.%john%'` - * Output: `[{ column: 'email', op: 'eq', value: 'john@example.com' }, { column: 'name', op: 'ilike', value: '%john%' }]` - */ -export function parseOrString(orString: string): PendingOrCondition[] { - const conditions: PendingOrCondition[] = [] - // Split on commas that are not inside parentheses (nested or/and) - const parts = splitOrString(orString) - - for (const part of parts) { - const trimmed = part.trim() - if (!trimmed) continue - - // Format: column.op.value - const firstDot = trimmed.indexOf('.') - if (firstDot === -1) continue - - const column = trimmed.slice(0, firstDot) - const rest = trimmed.slice(firstDot + 1) - - const secondDot = rest.indexOf('.') - if (secondDot === -1) continue - - const op = rest.slice(0, secondDot) as FilterOp - const value = rest.slice(secondDot + 1) - - // Handle special value formats - const parsedValue = parseOrValue(value) - - conditions.push({ column, op, value: parsedValue }) - } - - return conditions -} - -/** - * Rebuild an `.or()` string from structured conditions. - */ -export function rebuildOrString(conditions: PendingOrCondition[]): string { - return conditions - .map((c) => { - const value = formatOrValue(c.value) - return `${c.column}.${c.op}.${value}` - }) - .join(',') -} - -// --------------------------------------------------------------------------- -// Internal helpers -// --------------------------------------------------------------------------- - -function splitOrString(input: string): string[] { - const parts: string[] = [] - let current = '' - let depth = 0 - let inQuotes = false - - for (const char of input) { - if (char === '"' && depth === 0) { - inQuotes = !inQuotes - current += char - } else if (char === '(' && !inQuotes) { - depth++ - current += char - } else if (char === ')' && !inQuotes) { - depth-- - current += char - } else if (char === ',' && depth === 0 && !inQuotes) { - parts.push(current) - current = '' - } else { - current += char - } - } - - if (current) { - parts.push(current) - } - - return parts -} - -function parseOrValue(value: string): unknown { - // Handle double-quoted values (PostgREST quoting for reserved characters) - if (value.startsWith('"') && value.endsWith('"')) { - return value.slice(1, -1) - } - - // Handle parenthesized lists: (val1,val2,val3) - if (value.startsWith('(') && value.endsWith(')')) { - return value - .slice(1, -1) - .split(',') - .map((v) => v.trim()) - } - - // Handle booleans - if (value === 'true') return true - if (value === 'false') return false - - // Handle null - if (value === 'null') return null - - return value -} - -/** - * PostgREST reserved characters that require double-quoting in filter values. - * See: https://docs.postgrest.org/en/latest/references/api/tables_views.html - */ -const POSTGREST_RESERVED = /[,().]/ - -function formatOrValue(value: unknown): string { - if (Array.isArray(value)) { - return `(${value.join(',')})` - } - if (value === null) return 'null' - if (value === true) return 'true' - if (value === false) return 'false' - - const str = String(value) - - // Wrap in double quotes if the value contains reserved characters. - // This is required for encrypted values (JSON with commas, braces, etc.) - // and is safe for all string values per PostgREST spec. - if (POSTGREST_RESERVED.test(str)) { - return `"${str}"` - } - - return str -} diff --git a/packages/stack/src/supabase/index.ts b/packages/stack/src/supabase/index.ts deleted file mode 100644 index cd9a6bb79..000000000 --- a/packages/stack/src/supabase/index.ts +++ /dev/null @@ -1,130 +0,0 @@ -import type { AnyV3Table, InferPlaintext } from '@/eql/v3' -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' -import { EncryptedQueryBuilderImpl } from './query-builder' -import { EncryptedQueryBuilderV3Impl } from './query-builder-v3' -import type { - EncryptedQueryBuilderV3, - EncryptedSupabaseConfig, - EncryptedSupabaseInstance, - EncryptedSupabaseV3Config, - EncryptedSupabaseV3Instance, -} from './types' - -/** - * Create an encrypted Supabase wrapper that transparently handles encryption - * and decryption for queries on encrypted columns. - * - * @param config - Configuration containing the encryption client and Supabase client. - * @returns An object with a `from()` method that mirrors `supabase.from()` but - * auto-encrypts mutations, adds `::jsonb` casts, encrypts filter values, and - * decrypts results. - * - * @example - * ```typescript - * import { Encryption } from '@cipherstash/stack' - * import { encryptedSupabase } from '@cipherstash/stack/supabase' - * import { encryptedTable, encryptedColumn } from '@cipherstash/stack/schema' - * - * const users = encryptedTable('users', { - * name: encryptedColumn('name').freeTextSearch().equality(), - * email: encryptedColumn('email').freeTextSearch().equality(), - * }) - * - * const client = await Encryption({ schemas: [users] }) - * const eSupabase = encryptedSupabase({ encryptionClient: client, supabaseClient: supabase }) - * - * // INSERT - auto-encrypts, auto-converts to PG composite - * await eSupabase.from('users', users) - * .insert({ name: 'John', email: 'john@example.com', age: 30 }) - * - * // SELECT with filter - auto-casts ::jsonb, auto-encrypts search term, auto-decrypts - * const { data } = await eSupabase.from('users', users) - * .select('id, email, name') - * .eq('email', 'john@example.com') - * ``` - */ -export function encryptedSupabase( - config: EncryptedSupabaseConfig, -): EncryptedSupabaseInstance { - const { encryptionClient, supabaseClient } = config - - return { - from = Record>( - tableName: string, - schema: EncryptedTable, - ) { - return new EncryptedQueryBuilderImpl( - tableName, - schema, - encryptionClient, - supabaseClient, - ) - }, - } -} - -/** - * Create an encrypted Supabase wrapper for **EQL v3** schemas — tables - * authored with `@cipherstash/stack/eql/v3` whose columns are native - * `eql_v3.*` domains. - * - * The public surface and call shape are identical to {@link encryptedSupabase} - * (`.eq/.neq/.in/.gt/.gte/.lt/.lte/.like/.ilike/.match/.or/.not/.filter`, - * `withLockContext`, `audit`); only the schema type and the wire encoding - * differ. The same Supabase caveats carry over: the `eql_v3` schema must be - * added to the project's **Exposed schemas** and granted to the Supabase - * roles for the operators to resolve, and encrypted `ORDER BY` is - * unsupported (range *filtering* works). - * - * @example - * ```typescript - * import { Encryption } from '@cipherstash/stack' - * import { encryptedTable, types } from '@cipherstash/stack/eql/v3' - * import { encryptedSupabaseV3 } from '@cipherstash/stack/supabase' - * - * const users = encryptedTable('users', { - * email: types.TextSearch('email'), // eql_v3.text_search - * amount: types.IntegerOrd('amount'), // eql_v3.integer_ord - * }) - * - * const client = await Encryption({ schemas: [users] }) - * const es = encryptedSupabaseV3({ encryptionClient: client, supabaseClient: supabase }) - * - * await es.from('users', users).insert({ email: 'a@b.com', amount: 30 }) - * await es.from('users', users).select('id, email, amount').eq('email', 'a@b.com') - * await es.from('users', users).select('id, amount').gte('amount', 10).lte('amount', 100) - * ``` - */ -export function encryptedSupabaseV3( - config: EncryptedSupabaseV3Config, -): EncryptedSupabaseV3Instance { - const { encryptionClient, supabaseClient } = config - - return { - from< - Table extends AnyV3Table, - Row extends Record = InferPlaintext
, - >(tableName: string, table: Table) { - return new EncryptedQueryBuilderV3Impl( - tableName, - table, - encryptionClient, - supabaseClient, - ) as unknown as EncryptedQueryBuilderV3 - }, - } -} - -export type { - EncryptedQueryBuilder, - EncryptedQueryBuilderV3, - EncryptedSupabaseConfig, - EncryptedSupabaseError, - EncryptedSupabaseInstance, - EncryptedSupabaseResponse, - EncryptedSupabaseV3Config, - EncryptedSupabaseV3Instance, - PendingOrCondition, - SupabaseClientLike, - V3FilterableKeys, -} from './types' diff --git a/packages/stack/src/supabase/query-builder-v3.ts b/packages/stack/src/supabase/query-builder-v3.ts deleted file mode 100644 index 83b28921b..000000000 --- a/packages/stack/src/supabase/query-builder-v3.ts +++ /dev/null @@ -1,325 +0,0 @@ -import type { EncryptionClient } from '@/encryption' -import type { AnyV3Table } from '@/eql/v3' -import { EncryptedV3Column } from '@/eql/v3/columns' -import type { - ColumnSchema, - EncryptedTable, - EncryptedTableColumn, -} from '@/schema' -import type { BuildableQueryColumn, ScalarQueryTerm } from '@/types' -import { logger } from '@/utils/logger' -import { addJsonbCastsV3 } from './helpers' -import { - EncryptedQueryBuilderImpl, - EncryptionFailedError, -} from './query-builder' -import type { - FilterOp, - PendingOrCondition, - SupabaseClientLike, - SupabaseQueryBuilder, -} from './types' - -/** - * The subset of a v3 column builder the dialect relies on. Structural rather - * than the concrete class union so the runtime `instanceof EncryptedV3Column` - * gate and this type stay independent. - * - * Deliberately NOT `BuildableQueryColumn`'s `BuildableV3QueryableColumn` arm, - * despite the overlapping members: that type pins `isQueryable(): true`, and - * this map intentionally retains storage-only columns (whose `isQueryable()` - * is `false`) so a filter on one produces a precise error instead of passing - * through unencrypted. - */ -type V3ColumnLike = { - getName(): string - getEqlType(): string - getQueryCapabilities(): { - equality: boolean - orderAndRange: boolean - freeTextSearch: boolean - } - build(): ColumnSchema -} - -/** - * EQL v3 dialect of {@link EncryptedQueryBuilderImpl} for native `eql_v3.*` - * domain columns. The query mechanism is v2's — direct EQL operators over - * PostgREST — with four narrow forks: - * - * - **Column recognition / naming** — v3 columns are `EncryptedV3Column` - * builders and may map a JS property name to a different DB column name - * (`buildColumnKeyMap`). Filters, select casts, and mutations resolve - * property → DB name; select casts alias the DB column back to the property - * (`prop:db_name::jsonb`) so result rows keep property keys. - * - **Mutation encoding** — the raw encrypted payload object is sent (the - * `eql_v3.*` domains are `DOMAIN … AS jsonb`), not v2's `{ data: … }` - * composite wrap. - * - **Query-term encoding (INTERIM — tracked as CIP-3402)** — every filter - * operand is the FULL storage envelope from `encrypt()`, serialized as - * jsonb text. Why it is required today: each `eql_v3.*` domain CHECK - * requires the storage keys (`v`/`i`/`c` plus the domain's index terms), - * the SQL operator functions coerce their jsonb operand into the domain, - * and protect-ffi has no v3 scalar query wire shape (`encryptQuery` throws - * `EQL_V3_QUERY_UNSUPPORTED` on a v3 client) — so a term-only operand is - * impossible for EVERY domain, not just `text_search`. The full envelope - * satisfies the CHECK by construction and the operators extract the term - * they need (`eq_term`/`ord_term`/`match_term`). Caveat: operands carry a - * real ciphertext plus ALL index terms through PostgREST GET query strings - * (URL logs/proxies). Replaced by the EQL-side term-only scalar query - * envelope when it ships — see {@link encryptCollectedTerms}, the single - * swap point. - * - **`like`/`ilike`** — the v3 domains define no LIKE operator; free-text - * match is `@>` on the bloom filter. Encrypted pattern filters are emitted - * as PostgREST `cs` instead. (Match is tokenized + downcased, so `like` and - * `ilike` behave identically. For substring patterns to match, the column's - * match index should set `include_original: false` — with the default - * `true`, the full-envelope operand's bloom carries the whole pattern as an - * extra token that only matches when the pattern equals the stored value.) - * - * Decrypted rows additionally get `Date` reconstruction from the - * encrypt-config `cast_as`, mirroring the typed v3 client. - */ -export class EncryptedQueryBuilderV3Impl< - T extends Record = Record, -> extends EncryptedQueryBuilderImpl { - private v3Table: AnyV3Table - /** JS property name → DB column name, for every encrypted column. */ - private propToDb: Record - /** Built column schemas keyed by DB column name (for `cast_as`). */ - private columnSchemas: Record - /** Column builders keyed by BOTH property name and DB name. */ - private v3Columns: Record - /** - * Result-row key → DB column name for the columns the current select - * produces, including user-chosen PostgREST aliases (`ts:created_at` keys - * rows by `ts`). Populated by {@link buildSelectString}; consumed by - * {@link postprocessDecryptedRow} so aliased date columns still get `Date` - * reconstruction. - */ - private selectKeyToDb: Record = {} - - constructor( - tableName: string, - table: AnyV3Table, - encryptionClient: EncryptionClient, - supabaseClient: SupabaseClientLike, - ) { - super( - tableName, - // The base class only ever calls BuildableTable members on the schema - // (build / encryptModel plumbing); every v2-specific behaviour is - // overridden below. - table as unknown as EncryptedTable, - encryptionClient, - supabaseClient, - ) - - this.v3Table = table - this.propToDb = table.buildColumnKeyMap() - this.columnSchemas = table.build().columns - - this.v3Columns = {} - for (const [property, builder] of Object.entries(table.columnBuilders)) { - if (builder instanceof EncryptedV3Column) { - const col = builder as unknown as V3ColumnLike - this.v3Columns[property] = col - this.v3Columns[col.getName()] = col - } - } - - // The base class derives encrypted column names from build(), which v3 - // keys by DB name. Filters and select strings address columns by JS - // property name, so recognition must cover both. - this.encryptedColumnNames = Object.keys(this.v3Columns) - } - - // --------------------------------------------------------------------------- - // Dialect overrides - // --------------------------------------------------------------------------- - - protected override getColumnMap(): Record { - return this.v3Columns as unknown as Record - } - - protected override filterColumnName(column: string): string { - return this.propToDb[column] ?? column - } - - protected override buildSelectString(): string | null { - if (this.selectColumns === null) return null - const { select, keyToDb } = addJsonbCastsV3( - this.selectColumns, - this.propToDb, - ) - this.selectKeyToDb = keyToDb - return select - } - - /** v3 domains are plain jsonb — send the raw payload, keyed by DB name. */ - protected override transformEncryptedMutationModel( - model: Record, - ): Record { - const out: Record = {} - for (const [key, value] of Object.entries(model)) { - out[this.propToDb[key] ?? key] = value - } - return out - } - - protected override transformEncryptedMutationModels( - models: Record[], - ): Record[] { - return models.map((model) => this.transformEncryptedMutationModel(model)) - } - - /** - * Encrypt every filter operand as a full storage envelope (see the class - * doc for why `encryptQuery` terms cannot be used), serialized to jsonb - * text for the PostgREST filter value. - * - * INTERIM + single swap point. The full-envelope operand is a tracked - * workaround (Linear CIP-3402), not the design: it carries a real - * decryptable ciphertext `c` plus ALL of the column's index terms, and - * PostgREST filters travel in GET query strings — so operands can land in - * URL logs, proxies, and Supabase request logs (query terms are meant to - * be index-terms-only). When the EQL term-only scalar query envelope (the - * scalar analog of `eql_v3.jsonb_query`) ships, swapping the encryption - * call inside THIS method — and its `JSON.stringify` wire encoding — must - * be the ONLY change needed: every consuming seam (filter application, - * `or`/`not` transforms, the wire-operator remap) treats the returned - * operand as an opaque, already-encoded string and is encoding-agnostic. - * Do not let operand-encoding knowledge leak out of this method. - */ - protected override async encryptCollectedTerms( - terms: ScalarQueryTerm[], - ): Promise { - return Promise.all( - terms.map(async (term) => { - const column = term.column as unknown as V3ColumnLike - const queryType = term.queryType ?? 'equality' - const capabilities = column.getQueryCapabilities() - - // encrypt(null) short-circuits to null, which JSON.stringify would - // turn into the literal string "null" — a silently-wrong operand. - if (term.value == null) { - throw new Error( - `[supabase v3]: cannot encrypt a null filter value for column "${column.getName()}" — use .is('${column.getName()}', null) for NULL checks`, - ) - } - - if ( - queryType !== 'equality' && - queryType !== 'orderAndRange' && - queryType !== 'freeTextSearch' - ) { - throw new Error( - `[supabase v3]: query type "${queryType}" is not supported on scalar eql_v3 columns`, - ) - } - - if (!capabilities[queryType]) { - throw new Error( - `[supabase v3]: column "${column.getName()}" (${column.getEqlType()}) does not support ${queryType} queries — declare the column with a domain that carries that capability`, - ) - } - - const baseOp = this.encryptionClient.encrypt(term.value, { - column, - table: this.v3Table, - }) - const op = this.lockContext - ? baseOp.withLockContext(this.lockContext) - : baseOp - if (this.auditConfig) op.audit(this.auditConfig) - - const result = await op - if (result.failure) { - logger.error( - `Supabase: failed to encrypt query terms for table "${this.tableName}"`, - ) - - throw new EncryptionFailedError( - `Failed to encrypt query terms: ${result.failure.message}`, - result.failure, - ) - } - - return JSON.stringify(result.data) - }), - ) - } - - /** - * The single source of the encrypted wire-operator remap: `like`/`ilike` - * on an encrypted column become PostgREST `cs` (bloom-filter `@>`) — the - * `eql_v3.*` domains define no LIKE operator. Every pattern-bearing seam - * (`applyPatternFilter`, `notFilterOperator`, `transformOrConditions`) - * derives its operator here so they cannot drift apart. - */ - private encryptedFilterOp(op: string, wasEncrypted: boolean): string { - return wasEncrypted && (op === 'like' || op === 'ilike') ? 'cs' : op - } - - /** Encrypted pattern filters go through the bloom-filter `@>` (`cs`). */ - protected override applyPatternFilter( - q: SupabaseQueryBuilder, - column: string, - op: 'like' | 'ilike', - value: unknown, - wasEncrypted: boolean, - ): SupabaseQueryBuilder { - const wireOp = this.encryptedFilterOp(op, wasEncrypted) - if (wireOp !== op) { - return q.filter(column, wireOp, value) - } - return super.applyPatternFilter(q, column, op, value, wasEncrypted) - } - - protected override notFilterOperator( - op: FilterOp, - wasEncrypted: boolean, - ): string { - return this.encryptedFilterOp(op, wasEncrypted) - } - - protected override transformOrConditions( - conditions: PendingOrCondition[], - encryptedIndexes: Set, - ): PendingOrCondition[] { - return conditions.map((cond, j) => ({ - ...cond, - column: this.filterColumnName(cond.column), - op: this.encryptedFilterOp(cond.op, encryptedIndexes.has(j)) as FilterOp, - })) - } - - /** Rebuild `Date` values from the encrypt-config `cast_as`, mirroring the - * typed v3 client's decrypt-model path. */ - protected override postprocessDecryptedRow( - row: Record, - ): Record { - // Row key → DB column name for every key an encrypted column can appear - // under: the select's actual keys (including user-chosen aliases like - // `ts:created_at`) plus the static property/DB names as a fallback for - // paths with no recorded select. - const keyToDb: Record = { ...this.selectKeyToDb } - for (const [property, dbName] of Object.entries(this.propToDb)) { - keyToDb[property] ??= dbName - keyToDb[dbName] ??= dbName - } - - const out: Record = { ...row } - for (const [key, dbName] of Object.entries(keyToDb)) { - // Both 'date' and 'timestamp' columns decrypt to a JS `Date`. - const castAs = this.columnSchemas[dbName]?.cast_as - if (castAs !== 'date' && castAs !== 'timestamp') continue - const value = out[key] - if (value == null || value instanceof Date) continue - if (typeof value === 'string' || typeof value === 'number') { - out[key] = new Date(value) - } - } - return out - } -} diff --git a/packages/stack/src/supabase/types.ts b/packages/stack/src/supabase/types.ts deleted file mode 100644 index c24792d9f..000000000 --- a/packages/stack/src/supabase/types.ts +++ /dev/null @@ -1,391 +0,0 @@ -import type { EncryptionClient } from '@/encryption' -import type { AuditConfig } from '@/encryption/operations/base-operation' -import type { AnyV3Table, InferPlaintext, QueryTypesForColumn } from '@/eql/v3' -import type { EncryptionError } from '@/errors' -import type { LockContext } from '@/identity' -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' - -// --------------------------------------------------------------------------- -// Config & instance -// --------------------------------------------------------------------------- - -export type EncryptedSupabaseConfig = { - encryptionClient: EncryptionClient - supabaseClient: SupabaseClientLike -} - -export interface EncryptedSupabaseInstance { - from = Record>( - tableName: string, - schema: EncryptedTable, - ): EncryptedQueryBuilder -} - -// --------------------------------------------------------------------------- -// EQL v3 config & instance -// --------------------------------------------------------------------------- - -export type EncryptedSupabaseV3Config = { - encryptionClient: EncryptionClient - supabaseClient: SupabaseClientLike -} - -/** - * The column builders declared on a v3 table, recovered from the table's - * type-level `_columnType` brand. - */ -type V3ColumnsOfTable
= Table extends { - readonly _columnType: infer C -} - ? C - : never - -/** - * JS property names of a v3 table's storage-only columns — those whose domain - * exposes no query capability (e.g. `types.Bool`, `types.Text`). Excluded from - * the filterable keys so a filter on one is a type error, matching the runtime - * guard in the v3 term encryption path. - */ -export type NonQueryableV3Keys
= { - [K in Extract, string>]: [ - QueryTypesForColumn[K]>, - ] extends [never] - ? K - : never -}[Extract, string>] - -/** - * Row keys a v3 builder accepts in filter methods: every row key except the - * table's storage-only encrypted columns. Plaintext (non-schema) columns pass - * through untouched, exactly as in v2. - */ -export type V3FilterableKeys< - Table extends AnyV3Table, - Row extends Record, -> = Exclude, NonQueryableV3Keys
> - -/** - * The v3 builder type: the shared {@link EncryptedQueryBuilder} surface with - * filter methods narrowed to {@link V3FilterableKeys}. - */ -export type EncryptedQueryBuilderV3< - Table extends AnyV3Table, - Row extends Record, -> = EncryptedQueryBuilder & StringKeyOf> - -export interface EncryptedSupabaseV3Instance { - /** - * `Row` defaults to exactly the table's inferred plaintext shape — NOT - * widened with an index signature. Widening would collapse - * {@link V3FilterableKeys} to `string` and silently disable the - * storage-only-column filter guard. The trade-off: with the default `Row`, - * plaintext passthrough columns (`id`, `created_at`, …) are not filterable - * or insertable at the type level — pass an explicit `Row` that includes - * them (`es.from(…)`). - */ - from< - Table extends AnyV3Table, - Row extends Record = InferPlaintext
, - >(tableName: string, table: Table): EncryptedQueryBuilderV3 -} - -// --------------------------------------------------------------------------- -// Response -// --------------------------------------------------------------------------- - -export type EncryptedSupabaseResponse = { - data: T | null - error: EncryptedSupabaseError | null - count: number | null - status: number - statusText: string -} - -export type EncryptedSupabaseError = { - message: string - details?: string - hint?: string - code?: string - encryptionError?: EncryptionError -} - -// --------------------------------------------------------------------------- -// Internal builder state -// --------------------------------------------------------------------------- - -export type FilterOp = - | 'eq' - | 'neq' - | 'like' - | 'ilike' - | 'in' - | 'gt' - | 'gte' - | 'lt' - | 'lte' - | 'is' - -export type PendingFilter = { - op: FilterOp - column: string - value: unknown -} - -export type PendingOrFilter = - | { kind: 'structured'; conditions: PendingOrCondition[] } - | { kind: 'string'; value: string; referencedTable?: string } - -export type PendingOrCondition = { - column: string - op: FilterOp - value: unknown -} - -export type PendingMatchFilter = { - query: Record -} - -export type PendingNotFilter = { - column: string - op: FilterOp - value: unknown -} - -export type PendingRawFilter = { - column: string - operator: string - value: unknown -} - -export type TransformOp = - | { - kind: 'order' - column: string - options?: { - ascending?: boolean - nullsFirst?: boolean - referencedTable?: string - foreignTable?: string - } - } - | { - kind: 'limit' - count: number - options?: { referencedTable?: string; foreignTable?: string } - } - | { - kind: 'range' - from: number - to: number - options?: { referencedTable?: string; foreignTable?: string } - } - | { kind: 'single' } - | { kind: 'maybeSingle' } - | { kind: 'csv' } - | { kind: 'abortSignal'; signal: AbortSignal } - | { kind: 'throwOnError' } - | { kind: 'returns' } - -export type MutationOp = - | { - kind: 'insert' - data: Record | Record[] - options?: { - count?: 'exact' | 'planned' | 'estimated' - defaultToNull?: boolean - onConflict?: string - } - } - | { - kind: 'update' - data: Record - options?: { count?: 'exact' | 'planned' | 'estimated' } - } - | { - kind: 'upsert' - data: Record | Record[] - options?: { - count?: 'exact' | 'planned' | 'estimated' - onConflict?: string - ignoreDuplicates?: boolean - defaultToNull?: boolean - } - } - | { kind: 'delete'; options?: { count?: 'exact' | 'planned' | 'estimated' } } - -export type ResultMode = 'array' | 'single' | 'maybeSingle' - -// --------------------------------------------------------------------------- -// Minimal Supabase client shape (to avoid hard dependency) -// --------------------------------------------------------------------------- - -export interface SupabaseQueryBuilder { - select( - columns?: string, - options?: { head?: boolean; count?: 'exact' | 'planned' | 'estimated' }, - ): SupabaseQueryBuilder - insert( - values: unknown, - options?: Record, - ): SupabaseQueryBuilder - update( - values: unknown, - options?: Record, - ): SupabaseQueryBuilder - upsert( - values: unknown, - options?: Record, - ): SupabaseQueryBuilder - delete(options?: Record): SupabaseQueryBuilder - eq(column: string, value: unknown): SupabaseQueryBuilder - neq(column: string, value: unknown): SupabaseQueryBuilder - gt(column: string, value: unknown): SupabaseQueryBuilder - gte(column: string, value: unknown): SupabaseQueryBuilder - lt(column: string, value: unknown): SupabaseQueryBuilder - lte(column: string, value: unknown): SupabaseQueryBuilder - like(column: string, value: unknown): SupabaseQueryBuilder - ilike(column: string, value: unknown): SupabaseQueryBuilder - is(column: string, value: unknown): SupabaseQueryBuilder - in(column: string, values: unknown[]): SupabaseQueryBuilder - filter(column: string, operator: string, value: unknown): SupabaseQueryBuilder - not(column: string, operator: string, value: unknown): SupabaseQueryBuilder - or( - filters: string, - options?: { referencedTable?: string; foreignTable?: string }, - ): SupabaseQueryBuilder - match(query: Record): SupabaseQueryBuilder - order(column: string, options?: Record): SupabaseQueryBuilder - limit(count: number, options?: Record): SupabaseQueryBuilder - range( - from: number, - to: number, - options?: Record, - ): SupabaseQueryBuilder - single(): SupabaseQueryBuilder - maybeSingle(): SupabaseQueryBuilder - csv(): SupabaseQueryBuilder - abortSignal(signal: AbortSignal): SupabaseQueryBuilder - throwOnError(): SupabaseQueryBuilder - returns(): SupabaseQueryBuilder - then( - onfulfilled?: ((value: unknown) => unknown) | null, - onrejected?: ((reason: unknown) => unknown) | null, - ): Promise -} - -// eslint-disable-next-line @typescript-eslint/no-explicit-any -export interface SupabaseClientLike { - from(table: string): any -} - -// --------------------------------------------------------------------------- -// Re-export for convenience -// --------------------------------------------------------------------------- - -export type { EncryptionClient } from '@/encryption' -export type { AuditConfig } from '@/encryption/operations/base-operation' -export type { LockContext } from '@/identity' -export type { - EncryptedColumn, - EncryptedTable, - EncryptedTableColumn, -} from '@/schema' - -// --------------------------------------------------------------------------- -// Forward declaration for query builder (avoids circular) -// --------------------------------------------------------------------------- - -/** Helper to extract string keys from T */ -type StringKeyOf = Extract - -export interface EncryptedQueryBuilder< - T extends Record = Record, - FK extends StringKeyOf = StringKeyOf, -> extends PromiseLike> { - select( - columns: string, - options?: { head?: boolean; count?: 'exact' | 'planned' | 'estimated' }, - ): EncryptedQueryBuilder - insert( - data: Partial | Partial[], - options?: { - count?: 'exact' | 'planned' | 'estimated' - defaultToNull?: boolean - onConflict?: string - }, - ): EncryptedQueryBuilder - update( - data: Partial, - options?: { count?: 'exact' | 'planned' | 'estimated' }, - ): EncryptedQueryBuilder - upsert( - data: Partial | Partial[], - options?: { - count?: 'exact' | 'planned' | 'estimated' - onConflict?: string - ignoreDuplicates?: boolean - defaultToNull?: boolean - }, - ): EncryptedQueryBuilder - delete(options?: { - count?: 'exact' | 'planned' | 'estimated' - }): EncryptedQueryBuilder - eq(column: K, value: T[K]): EncryptedQueryBuilder - neq(column: K, value: T[K]): EncryptedQueryBuilder - gt(column: K, value: T[K]): EncryptedQueryBuilder - gte(column: K, value: T[K]): EncryptedQueryBuilder - lt(column: K, value: T[K]): EncryptedQueryBuilder - lte(column: K, value: T[K]): EncryptedQueryBuilder - like(column: K, pattern: string): EncryptedQueryBuilder - ilike(column: K, pattern: string): EncryptedQueryBuilder - is( - column: K, - value: null | boolean, - ): EncryptedQueryBuilder - in(column: K, values: T[K][]): EncryptedQueryBuilder - filter( - column: K, - operator: string, - value: T[K], - ): EncryptedQueryBuilder - not( - column: K, - operator: string, - value: T[K], - ): EncryptedQueryBuilder - or( - filters: string, - options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder - or( - conditions: PendingOrCondition[], - options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder - match(query: Partial>): EncryptedQueryBuilder - order>( - column: K, - options?: { - ascending?: boolean - nullsFirst?: boolean - referencedTable?: string - foreignTable?: string - }, - ): EncryptedQueryBuilder - limit( - count: number, - options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder - range( - from: number, - to: number, - options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder - single(): EncryptedQueryBuilder - maybeSingle(): EncryptedQueryBuilder - csv(): EncryptedQueryBuilder - abortSignal(signal: AbortSignal): EncryptedQueryBuilder - throwOnError(): EncryptedQueryBuilder - returns>(): EncryptedQueryBuilder - withLockContext(lockContext: LockContext): EncryptedQueryBuilder - audit(config: AuditConfig): EncryptedQueryBuilder -} diff --git a/packages/stack/src/types.ts b/packages/stack/src/types.ts index 54ef574d7..23a6b9eb7 100644 --- a/packages/stack/src/types.ts +++ b/packages/stack/src/types.ts @@ -77,21 +77,21 @@ export type EncryptedQuery = * Plaintext values the SDK accepts for encryption. * * Widens the FFI's `JsPlaintext` (`string | number | boolean | - * Record | JsPlaintext[]`) with `Date`. `Date` is a supported - * cast target that is omitted from the FFI's `JsPlaintext` INPUT union, but it - * serializes at the boundary via `toJSON` (ISO string), so it is accepted on the - * way in. + * Record | JsPlaintext[]`) with `Date` and `bigint`. `Date` + * is a supported cast target that is omitted from the FFI's `JsPlaintext` INPUT + * union, but it serializes at the boundary via `toJSON` (ISO string), so it is + * accepted on the way in. * - * `bigint` is intentionally NOT included: the native `@cipherstash/protect-ffi` - * build cannot marshal a JS `bigint` (V8 throws "Do not know how to serialize a - * BigInt") and rejects a `string` for a `big_int` column. The v3 int8 domains - * are therefore omitted from the SDK entirely (see `eql/v3`) until the FFI - * supports lossless bigint I/O; `bigint` returns here alongside them. + * `bigint` is the plaintext for the v3 int8/bigint domains (see `eql/v3`), + * which always decrypt to a JS `bigint`. protect-ffi 0.28 marshals a native + * `bigint` across the Neon boundary losslessly. i64 bounds + * (`-2^63 … 2^63 - 1`) are enforced at the protect-ffi boundary, not here — + * out-of-range values surface as encryption errors from the FFI. * - * When the upstream FFI `JsPlaintext` is corrected to include `Date`, the `Date` - * arm can collapse back into `JsPlaintext`. + * When the upstream FFI `JsPlaintext` includes `Date` and `bigint`, both extra + * arms can collapse back into `JsPlaintext`. */ -export type Plaintext = JsPlaintext | Date +export type Plaintext = JsPlaintext | Date | bigint // --------------------------------------------------------------------------- // Client configuration @@ -191,9 +191,10 @@ export type ClientConfig = { * `decrypt` accepts BOTH formats regardless of this setting, so v2 and * v3 data can coexist during a migration. * - * v3 limitation (protect-ffi 0.27): `encryptQuery` supports only JSON - * containment queries — scalar-index and selector queries throw - * `EQL_V3_QUERY_UNSUPPORTED` until a v3 scalar query wire shape exists. + * Under `3`, `encryptQuery` returns EQL v3 query operands (protect-ffi + * 0.29+): term-only scalar operands for the `eql_v3.query_` twins, + * the `eql_v3.query_jsonb` containment needle, and bare selector-hash + * strings for JSON path queries. */ eqlVersion?: 2 | 3 } @@ -434,7 +435,7 @@ export type QueryTypeName = | 'searchableJson' /** @internal */ -export type FfiIndexTypeName = 'ore' | 'match' | 'unique' | 'ste_vec' +export type FfiIndexTypeName = 'ore' | 'ope' | 'match' | 'unique' | 'ste_vec' export const queryTypes = { orderAndRange: 'orderAndRange', @@ -447,6 +448,8 @@ export const queryTypes = { /** @internal */ export const queryTypeToFfi: Record = { + // v3 `_ord` domains carry `ope` instead — `resolveIndexType` swaps this + // static default for the ordering index the column actually configures. orderAndRange: 'ore', freeTextSearch: 'match', equality: 'unique', diff --git a/packages/stack/src/wasm-inline.ts b/packages/stack/src/wasm-inline.ts index 54ff117bc..4f3b9eab9 100644 --- a/packages/stack/src/wasm-inline.ts +++ b/packages/stack/src/wasm-inline.ts @@ -10,13 +10,16 @@ * * Use this import path: `@cipherstash/stack/wasm-inline` * + * This entry is EQL v3: author schemas with the `types` DSL / `encryptedTable` + * re-exported here (the same authoring surface as `@cipherstash/stack/eql/v3`). + * * @example * ```ts * import { - * Encryption, encryptedTable, encryptedColumn, + * Encryption, encryptedTable, types, * } from "@cipherstash/stack/wasm-inline" * - * const users = encryptedTable("users", { email: encryptedColumn("email") }) + * const users = encryptedTable("users", { email: types.TextSearch("email") }) * * const client = await Encryption({ * schemas: [users], @@ -67,12 +70,10 @@ import { isEncrypted as wasmIsEncrypted, newClient as wasmNewClient, } from '@cipherstash/protect-ffi/wasm-inline' +import { type AnyV3Table, buildEncryptConfig } from '@/eql/v3' import { - buildEncryptConfig, type CastAs, type EncryptConfig, - type EncryptedTable, - type EncryptedTableColumn, encryptConfigSchema, toEqlCastAs, } from '@/schema' @@ -91,19 +92,13 @@ export { AccessKeyStrategy, OidcFederationStrategy, } from '@cipherstash/auth/wasm-inline' -export type { - EncryptedColumn, - EncryptedField, - EncryptedTable, - EncryptedTableColumn, - InferEncrypted, - InferPlaintext, -} from '@/schema' -export { - encryptedColumn, - encryptedField, - encryptedTable, -} from '@/schema' +// The WASM entry is EQL v3. Its authoring surface — `types`, `encryptedTable`, +// the column classes, `buildEncryptConfig`, and the inference helpers — is the +// v3 one, re-exported wholesale so an edge consumer authors v3 schemas from this +// single import. The v2 builders are intentionally NOT exported here: the WASM +// path was never announced or documented for v2, and the edge targets v3. EQL v2 +// remains fully available on the native `@cipherstash/stack` entry. +export * from '@/eql/v3' export type { Encrypted } from '@/types' /** Re-exported convenience predicate — same as the raw protect-ffi one. */ @@ -125,12 +120,18 @@ export function isEncrypted(value: unknown): boolean { /** * The plaintext shape accepted by `encrypt` and returned by `decrypt`. * Mirrors protect-ffi's `JsPlaintext` (recursive: arrays of any of - * these are valid). Re-defined here so the wasm-inline `.d.ts` doesn't - * pull in the Node-only protect-ffi types. + * these are valid), plus `bigint` for `int8` columns. Re-defined here so + * the wasm-inline `.d.ts` doesn't pull in the Node-only protect-ffi types. + * + * `bigint` is carried natively across the wasm boundary by protect-ffi + * 0.28's Rust `encode_plaintext` (which i64-bounds-checks on encrypt and + * builds a `js_sys::BigInt` on decrypt), so widening the type here is all + * the SDK needs to accept/return `bigint` on the wasm entry point. */ export type WasmPlaintext = | string | number + | bigint | boolean | null | Record @@ -223,10 +224,9 @@ export type WasmClientConfig = { export type WasmAuthStrategy = AccessKeyStrategy | OidcFederationStrategy export type WasmEncryptionConfig = { - schemas: [ - EncryptedTable, - ...EncryptedTable[], - ] + /** One or more EQL v3 tables, authored with `types` / `encryptedTable` from + * this entry. The WASM entry is EQL v3 only. */ + schemas: [AnyV3Table, ...AnyV3Table[]] config: WasmClientConfig } @@ -315,20 +315,38 @@ export async function Encryption( ) } + // The WASM entry is EQL v3 only. The types enforce v3 tables, but a plain-JS + // caller can bypass that — reject a non-v3 table (one lacking the v3 + // `buildColumnKeyMap` marker) with a clear message rather than pinning the + // client to v3 wire against a v2 schema and failing opaquely inside the FFI. + for (const table of schemas) { + const isV3 = + typeof (table as { buildColumnKeyMap?: unknown }).buildColumnKeyMap === + 'function' + if (!isV3) { + throw new Error( + '[encryption]: `@cipherstash/stack/wasm-inline` is EQL v3 only — author schemas with `types` / `encryptedTable` from this entry. (EQL v2 is available on the native `@cipherstash/stack` entry.)', + ) + } + } + const encryptConfig: EncryptConfig = encryptConfigSchema.parse( buildEncryptConfig(...schemas), ) const strategy = resolveStrategy(clientConfig) - // protect-ffi 0.25 takes a single options object with the strategy - // nested under `strategy` (0.24 passed the strategy as a separate - // first argument). + // protect-ffi 0.25 takes a single options object with the strategy nested + // under `strategy` (0.24 passed the strategy as a separate first argument). + // `eqlVersion: 3` pins the EQL v3 wire format — this entry is v3 only, so + // every encrypt/query emits v3 (a v2-mode client cannot resolve the concrete + // `eql_v3_*` domains and would fail every encrypt). const client = await wasmNewClient({ strategy, encryptConfig: normalizeCastAs(encryptConfig), clientId: clientConfig.clientId, clientKey: clientConfig.clientKey, + eqlVersion: 3, } as never) // `INTERNAL_CONSTRUCT` is module-scoped, so this factory is the only diff --git a/packages/stack/tsconfig.json b/packages/stack/tsconfig.json index 515c043f4..d0a2140d5 100644 --- a/packages/stack/tsconfig.json +++ b/packages/stack/tsconfig.json @@ -35,7 +35,24 @@ // Paths "paths": { - "@/*": ["./src/*"] + "@/*": ["./src/*"], + + // The v3 domain catalog lives in `@cipherstash/test-kit`, which imports + // stack through its PUBLIC subpaths (packages outside stack cannot use + // `@/`). `tsc` does not read Vitest's `resolve.alias`, so without these + // the catalog's builders lose their precise return types and the + // `.test-d.ts` matrix collapses to `never`. Mirrors `vitest.shared.ts` + // and `packages/test-kit/tsconfig.json`; keep the three in step. + "@cipherstash/test-kit": ["../test-kit/src/index.ts"], + "@cipherstash/test-kit/suite": ["../test-kit/src/run-family-suite.ts"], + "@cipherstash/test-kit/integration-clerk": [ + "../test-kit/src/integration/clerk.ts" + ], + "@cipherstash/test-kit/catalog": ["../test-kit/src/catalog.ts"], + "@cipherstash/stack": ["./src/index.ts"], + "@cipherstash/stack/eql/v3": ["./src/eql/v3/index.ts"], + "@cipherstash/stack/schema": ["./src/schema/index.ts"], + "@cipherstash/stack/v3": ["./src/encryption/v3.ts"] } } } diff --git a/packages/stack/tsup.config.ts b/packages/stack/tsup.config.ts index 100065f0c..413934516 100644 --- a/packages/stack/tsup.config.ts +++ b/packages/stack/tsup.config.ts @@ -15,12 +15,11 @@ export default defineConfig([ 'src/identity/index.ts', 'src/schema/index.ts', 'src/eql/v3/index.ts', - 'src/drizzle/index.ts', 'src/dynamodb/index.ts', - 'src/supabase/index.ts', 'src/encryption/index.ts', 'src/encryption/v3.ts', 'src/errors/index.ts', + 'src/adapter-kit.ts', ], format: ['cjs', 'esm'], sourcemap: true, @@ -28,7 +27,6 @@ export default defineConfig([ clean: false, target: 'es2022', tsconfig: './tsconfig.json', - external: ['drizzle-orm', '@supabase/supabase-js'], // zod + @byteslice/result are bundled so dist/wasm-inline.js carries // no bare-specifier transitive imports — important for Deno / Edge / // browser consumers whose runtime won't resolve npm names without an @@ -50,7 +48,6 @@ export default defineConfig([ clean: false, target: 'es2022', tsconfig: './tsconfig.json', - external: ['drizzle-orm', '@supabase/supabase-js'], noExternal: ['evlog', 'uuid', 'zod', '@byteslice/result'], }, ]) diff --git a/packages/stack/vitest.config.ts b/packages/stack/vitest.config.ts index c4b1da040..06413417f 100644 --- a/packages/stack/vitest.config.ts +++ b/packages/stack/vitest.config.ts @@ -1,31 +1,48 @@ -import { resolve } from 'node:path' -import { defineConfig } from 'vitest/config' +import { configDefaults, defineConfig } from 'vitest/config' +import { sharedAlias, stackSourceAlias } from '../../vitest.shared' 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', - ), - }, + // `sharedAlias` resolves `@cipherstash/test-kit` + the stack subpaths its + // catalog imports to source; `stackSourceAlias` adds stack's own `@/` alias + // and the `/wasm-inline` stubs (`src/wasm-inline.ts` imports subpaths Vitest + // can't resolve; unit tests that only touch pure helpers load the stub, tests + // needing real WASM mock the specifiers explicitly). Both point at fixed + // locations under packages/stack, so they live in vitest.shared. + alias: { ...sharedAlias, ...stackSourceAlias }, }, test: { + // Integration suites live in `integration/` and require credentials, a + // database and PostgREST. They THROW rather than skip when unconfigured, so + // they must never be picked up by `pnpm test` — that is the whole reason + // they are a separate config and a separate CI job. + exclude: [...configDefaults.exclude, 'integration/**'], + // Live suites make real ZeroKMS / CTS network round-trips. The vast + // majority of these tests already pass an explicit `, 30000)` per-test + // timeout (300+ call sites); a handful were written without one and so + // fell back to Vitest's 5000ms default. Under the default forks pool with + // file parallelism, many live suites hit ZeroKMS concurrently and those + // 5000ms-default tests intermittently time out (they pass in isolation). + // Align the global default with the dominant explicit value so the intent + // is uniform. 30s is comfortably above real network latency but still low + // enough to surface a genuine hang. + testTimeout: 30000, + hookTimeout: 30000, typecheck: { // Scoped tsconfig keeps the 124 pre-existing wasm-inline typecheck errors // out of scope (tracked as a follow-up). Run via the `test:types` script // with `--typecheck.only` so the runtime suites do NOT also execute. tsconfig: './tsconfig.typecheck.json', + // Type coverage lives in `*.test-d.ts`. M1 (the factory rejecting the + // `TypedEncryptionClient` that `EncryptionV3` returns) slipped through + // because the runtime `*.test.ts` suites are not typechecked. Rather than + // widen to those files — the drizzle-v3 suites are pervasively loose-typed + // by design (dynamic domain matrix: `as never` tables, untyped mock + // introspection, `readonly` sample tuples) so a wholesale widen surfaces + // dozens of pre-existing, unrelated errors AND risks exposing the + // wasm-inline errors via their imports — M1 and the A3 envelope contract + // are locked directly in `drizzle-v3/operators.test-d.ts` and + // `drizzle-v3/types.test-d.ts`, which this glob already covers. include: ['__tests__/**/*.test-d.ts'], }, }, diff --git a/packages/test-kit/package.json b/packages/test-kit/package.json new file mode 100644 index 000000000..f12c580cc --- /dev/null +++ b/packages/test-kit/package.json @@ -0,0 +1,24 @@ +{ + "name": "@cipherstash/test-kit", + "version": "0.0.0", + "private": true, + "description": "Shared EQL v3 test harness: the domain catalog, the plaintext oracle, and the integration-suite driver. Consumed as TypeScript source \u2014 no build step.", + "type": "module", + "exports": { + "./integration-clerk": "./src/integration/clerk.ts", + ".": "./src/index.ts", + "./catalog": "./src/catalog.ts", + "./suite": "./src/run-family-suite.ts" + }, + "scripts": { + "test:types": "tsc --noEmit -p tsconfig.json" + }, + "dependencies": { + "@cipherstash/stack": "workspace:*" + }, + "devDependencies": { + "@clerk/backend": "3.4.9", + "typescript": "catalog:repo", + "vitest": "catalog:repo" + } +} diff --git a/packages/test-kit/src/adapter.ts b/packages/test-kit/src/adapter.ts new file mode 100644 index 000000000..52670479d --- /dev/null +++ b/packages/test-kit/src/adapter.ts @@ -0,0 +1,76 @@ +import type { QueryOp, QueryOpKind } from './ops.ts' +import type { PlainRow, TableSpec } from './rows.ts' + +/** + * The seam between the shared driver and one adapter under test. + * + * The driver decides WHAT to assert — derived from the domain's capabilities — + * and the adapter decides HOW to express it. Keeping the adapters behind one + * interface is what stops Drizzle and Supabase from quietly covering different + * operations while both suites read as "comprehensive". + */ +export interface IntegrationAdapter { + readonly name: 'drizzle' | 'supabase' + + /** + * Operations this adapter can express at all, independent of any domain. Both + * adapters currently cover the full `QueryOpKind` union, `order` included: + * Drizzle emits `ORDER BY eql_v3.ord_term(col)`, and Supabase emits the jsonb + * path `col->op`, which selects the same order-preserving OPE term. (Ordering + * columns that lack an `ope` term are rejected by the capability matrix, not + * by this set.) + */ + readonly supportedOps: ReadonlySet + + /** + * Operations this adapter refuses on ANY encrypted column, regardless of its + * capabilities — the half of the contract the capability matrix cannot derive. + * Both adapters currently leave this empty: Supabase's one former entry, + * `order`, is now allowed on OPE columns and rejected on ORE/none by the + * ordering-flavour guard, which the capability matrix already drives. Kept as + * the seam for a future adapter with a genuinely unconditional refusal. + */ + readonly alwaysRejectedOps: ReadonlySet + + /** + * Whether the adapter has a SECOND, distinct code path for `in`-lists that the + * driver should exercise alongside the primary one. + * + * Supabase does: `.in()` and the raw `.filter(col, 'in', […])` are different + * code paths, and the raw one encrypted the whole list as a single term until + * recently. Drizzle has one `inArray`, so running the variant there would add + * a duplicate test under a name (`filter(in)`) that means nothing to it. + */ + readonly hasRawInListPath?: boolean + + setup(): Promise + teardown(): Promise + + /** Create the table: one column per family domain, every encrypted column NULLable. */ + createTable(table: TableSpec): Promise + + /** Insert one row through the adapter's single-encrypt path (`encryptModel`). */ + insertSingle(table: TableSpec, row: PlainRow): Promise + + /** Insert many rows through the adapter's bulk path (`bulkEncryptModels`). */ + insertBulk(table: TableSpec, rows: readonly PlainRow[]): Promise + + /** + * Run `op` and return the matching row keys. + * + * For `order`, return them in the order the database produced, and exclude + * NULLs — the seed set contains one all-NULL row, and NULL ordering is a + * property of the SQL dialect, not of the encrypted ordering term. Every + * other kind returns keys sorted ascending, so the driver can compare sets + * without caring about row order. + */ + run(table: TableSpec, op: QueryOp): Promise + + /** + * Assert `op` is rejected. Each adapter owns its error shape — + * `EncryptionOperatorError` for Drizzle, a `[supabase v3]` Error for + * Supabase — so the driver stays adapter-agnostic. Always async: wrap a + * synchronous throw. + */ + expectRejected(table: TableSpec, op: QueryOp): Promise +} diff --git a/packages/test-kit/src/catalog.ts b/packages/test-kit/src/catalog.ts new file mode 100644 index 000000000..d91454f88 --- /dev/null +++ b/packages/test-kit/src/catalog.ts @@ -0,0 +1,703 @@ +/** + * Type-driven v3 test matrix — single source of truth. + * + * The TypeScript analog of the Rust `eql_v3` `scalar_matrix!` harness + * (`encrypt-query-language/tests/sqlx`): one declarative catalog drives both a + * runtime `it.each` matrix (`matrix.test.ts`) and type-level assertions + * (`matrix.test-d.ts`), instead of hand-rolling per-domain test bodies. + * + * COVERAGE IS MANDATORY. The catalog is `satisfies Record`, and `EqlV3TypeName` is derived from the real column union + * (`AnyEncryptedV3Column`). Add a domain to the SDK and this file fails to + * compile until it has a row — the compile-time analog of, and stronger than, + * the Rust `test:matrix:inventory` cross-check (it names each missing domain). + * + * Every field here is consumed by a test: `builder`/`ColumnClass` by the + * instanceof check, `castAs` + `indexes` by the `build()` `toStrictEqual`, and + * `capabilities` by `getQueryCapabilities()`/`isQueryable()`. + */ + +import type { + AnyEncryptedV3Column, + EqlTypeForColumn, + JsonValue, + QueryCapabilities, +} from '@cipherstash/stack/eql/v3' +import { + EncryptedBigintColumn, + EncryptedBigintEqColumn, + EncryptedBigintOrdColumn, + EncryptedBigintOrdOreColumn, + EncryptedBooleanColumn, + EncryptedDateColumn, + EncryptedDateEqColumn, + EncryptedDateOrdColumn, + EncryptedDateOrdOreColumn, + EncryptedDoubleColumn, + EncryptedDoubleEqColumn, + EncryptedDoubleOrdColumn, + EncryptedDoubleOrdOreColumn, + EncryptedIntegerColumn, + EncryptedIntegerEqColumn, + EncryptedIntegerOrdColumn, + EncryptedIntegerOrdOreColumn, + EncryptedJsonColumn, + EncryptedNumericColumn, + EncryptedNumericEqColumn, + EncryptedNumericOrdColumn, + EncryptedNumericOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, + EncryptedTextColumn, + EncryptedTextEqColumn, + EncryptedTextMatchColumn, + EncryptedTextOrdColumn, + EncryptedTextOrdOreColumn, + EncryptedTextSearchColumn, + EncryptedTimestampColumn, + EncryptedTimestampEqColumn, + EncryptedTimestampOrdColumn, + EncryptedTimestampOrdOreColumn, + types, +} from '@cipherstash/stack/eql/v3' +import type { ColumnSchema } from '@cipherstash/stack/schema' + +/** + * The canonical union of every v3 domain name — derived STRAIGHT from the real + * column union (`AnyEncryptedV3Column`) via the exported `EqlTypeForColumn` + * helper, not hand-copied. This is the key set the `Record` below must cover. + */ +export type EqlV3TypeName = EqlTypeForColumn + +/** One row of the type-driven matrix: everything a test needs about a domain. */ +export type DomainSpec = Readonly<{ + /** Column builder under test. */ + builder: (name: string) => AnyEncryptedV3Column + /** Concrete class the builder must instantiate (`toBeInstanceOf`). */ + ColumnClass: new ( + ...args: never[] + ) => AnyEncryptedV3Column + /** Plaintext axis emitted by `build().cast_as`. */ + castAs: ColumnSchema['cast_as'] + /** Semantic capability flags (`getQueryCapabilities()`). */ + capabilities: QueryCapabilities + /** + * The full `build().indexes` output — stored as DATA per row (like the Rust + * harness) rather than derived from `capabilities`, because `text_search` + * overrides `build()` to emit `unique + ore + match` where the capability → + * index rule would omit `unique` for an order-capable column. + */ + indexes: ColumnSchema['indexes'] + /** + * Representative + edge plaintext values that MUST round-trip through live + * encrypt/decrypt (consumed by `matrix-live.test.ts`). Typed as the loose + * plaintext union rather than per-row: the precise `castAs → plaintext` axis + * is already proven at the type level in `matrix.test-d.ts` (`InferPlaintext`), + * and a per-row generic would break the single `satisfies Record<…>` that is + * this file's coverage mechanism. Numeric samples are split integer-vs- + * fractional: `build()` emits `cast_as:'number'` uniformly so the FFI can't + * tell `integer` from `double`, and a fractional value on an int-named domain is + * untested territory (it would truncate against a real narrow PG column). + */ + samples: ReadonlyArray + /** + * Values that MUST fail encryption. Number domains reject `NaN`/`±Infinity` + * and `bigint` domains reject values outside the signed 64-bit (`int8`) range + * — both via the same client-side guard (`assertValidNumericValue`). Domains + * whose plaintext type cannot express an invalid value omit this. + */ + errorSamples?: ReadonlyArray + /** + * Why the integration matrix does NOT exercise this domain. Absent means it + * is covered — the common case, so the exclusion is what has to be spelled + * out, not the inclusion. + * + * A deferred domain still needs a row here: the `satisfies Record<…>` below + * is the coverage mechanism, and dropping the row would hide the domain + * rather than document why it is skipped. The integration driver reads this + * field, skips the domain, and prints the reason — so removing coverage is + * always a visible, reviewable diff, never a silent omission. The unit + * matrix (`matrix.test.ts`) ignores it and exercises every domain. + */ + deferred?: string +}> + +/** + * Whether the integration matrix exercises this domain. See {@link DomainSpec.deferred}. + * + * Read through these accessors, not by touching `.deferred`: `V3_MATRIX` is + * `as const`, so a row that omits the field has no such property on its literal + * type and a direct access does not compile. Widening to `DomainSpec` here makes + * the optional field readable from every row. + */ +export function isCovered(spec: DomainSpec): boolean { + return spec.deferred === undefined +} + +/** Why the integration matrix skips this domain, or `undefined` if it does not. */ +export function deferredReason(spec: DomainSpec): string | undefined { + return spec.deferred +} + +/** + * `Object.entries` that preserves the literal key union instead of widening to + * `string` — so `eqlType` in the runtime matrix stays `EqlV3TypeName`. + */ +export function typedEntries( + obj: Record, +): Array<[K, V]> { + return Object.entries(obj) as Array<[K, V]> +} + +/** The schema the concrete EQL v3 domains live in — see `EqlV3TypeName`. */ +export const EQL_V3_DOMAIN_SCHEMA = 'public' + +/** + * A `public.eql_v3_integer_ord` domain reduced to a bare `integer_ord`, suitable as a + * column identifier in the test tables. Shared by every suite that builds a + * table from the matrix, so a future domain-schema move is a one-line change + * rather than five. + */ +export function eqlTypeSlug(eqlType: EqlV3TypeName | string): string { + const prefix = `${EQL_V3_DOMAIN_SCHEMA}.` + return eqlType.startsWith(prefix) ? eqlType.slice(prefix.length) : eqlType +} + +// Capability shorthands (mirror the SDK's internal presets). +const STORAGE = { + equality: false, + orderAndRange: false, + freeTextSearch: false, +} as const +const EQ = { + equality: true, + orderAndRange: false, + freeTextSearch: false, +} as const +const ORD = { + equality: true, + orderAndRange: true, + freeTextSearch: false, +} as const +const MATCH_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: true, +} as const +const FULL = { + equality: true, + orderAndRange: true, + freeTextSearch: true, +} as const + +// Index shorthands (mirror `build().indexes`). Type-annotated rather than +// `as const`: annotation contextually types the literals so enum fields like +// `kind: 'ngram'` stay checked against the schema while arrays remain MUTABLE +// — `ColumnSchema['indexes']` rejects the `readonly` arrays `as const` produces. +type Indexes = ColumnSchema['indexes'] +const NONE: Indexes = {} +const UNIQUE_IDX: Indexes = { unique: { token_filters: [] } } +// Ordering flavour is pinned by the domain name (eql-3.0.0): `_ord_ore` +// domains are block-ORE (`ore` index, `ob` term); plain `_ord` domains and +// `text_search` are CLLW-OPE (`ope` index, `op` term). +const ORE_IDX: Indexes = { ore: {} } +const OPE_IDX: Indexes = { ope: {} } +// Text order domains (`text_ord`, `text_ord_ore`) carry BOTH `hm` (unique) and +// their ordering term: their eql_v3 SQL domains require `hm` because text +// equality is HMAC-based, unlike numeric/date order domains which answer +// equality via the ordering term. +const TEXT_ORD_IDX: Indexes = { unique: { token_filters: [] }, ope: {} } +const TEXT_ORD_ORE_IDX: Indexes = { unique: { token_filters: [] }, ore: {} } +const MATCH_BLOCK: NonNullable['match'] = { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: false, +} +const MATCH_IDX: Indexes = { match: MATCH_BLOCK } +const TEXT_SEARCH_IDX: Indexes = { + unique: { token_filters: [] }, + ope: {}, + match: MATCH_BLOCK, +} + +// Sample plaintexts per plaintext axis, consumed by `matrix-live.test.ts`. +// Numeric sets are split by domain width: integers (incl. type bounds) for +// smallint/integer, fractionals for real/double/numeric. See `DomainSpec.samples`. +const SMALLINT_S = [0, -1, 32767, -32768] as const +const INTEGER_S = [0, -42, 2147483647, -2147483648] as const +// Full i64 bounds: i64::MAX, i64::MIN, zero, a negative, and a mid value beyond +// Number.MAX_SAFE_INTEGER to prove protect-ffi 0.28 round-trips a JS bigint +// losslessly. Values OUTSIDE this range are rejected client-side (BIGINT_ERR) +// before protect-ffi, mirroring how NUM_ERR guards the number domains. +const BIGINT_S = [ + 4611686018427387904n, + -42n, + 9223372036854775807n, + -9223372036854775808n, + 0n, +] as const +const REAL_S = [0, 77.5, -117.25, 0.5] as const +const DOUBLE_S = [0, -117.123456, 1e15, -1e15] as const +const NUMERIC_S = [0, 12345.678, -42, -0.5] as const +const TEXT_S = ['', 'ada@example.com', 'Ada Lovelace'] as const +// Text domains with an ordering term require non-empty positive samples to +// satisfy the real Postgres domain checks. Empty-string rejection is covered in +// matrix-live-pg. +const TEXT_ORE_S = [ + 'ada@example.com', + 'grace@example.com', + 'zora@example.org', +] as const +const BOOLEAN_S = [true, false] as const +const DATE_S = [ + new Date('2026-07-01T00:00:00.000Z'), + new Date('1970-01-01T00:00:00.000Z'), +] as const +// Timestamp domains (`cast_as: 'timestamp'`) preserve the full instant, unlike +// `date` which truncates to midnight. These samples deliberately carry a +// NON-ZERO time-of-day so the live round-trip actually detects a regression +// that truncates to the day boundary — reusing the midnight-only `DATE_S` here +// would let such a regression pass silently (see matrix.test.ts). +const TS_S = [ + new Date('2026-07-01T12:34:56.000Z'), + new Date('1970-01-01T23:59:59.000Z'), +] as const +// Every number domain rejects these via the global encrypt guard. +const NUM_ERR = [ + Number.NaN, + Number.POSITIVE_INFINITY, + Number.NEGATIVE_INFINITY, +] as const +// Every bigint domain rejects values outside the signed 64-bit (`int8`) range +// via the same guard — the bigint analog of NUM_ERR's NaN/±Infinity: i64::MAX+1 +// and i64::MIN-1. +const BIGINT_ERR = [9223372036854775808n, -9223372036854775809n] as const + +// biome-ignore format: one row per domain reads as a table; keep it dense. +/** + * The `_ord_ore` domains are block-ORE, whose operator class is superuser-only: + * the eql-3.0.0 bundle self-skips that statement on `insufficient_privilege`. + * + * Measured against `supabase/postgres:17.4.1.048` after `stash eql install + * --eql-version 3 --supabase --direct`, as the non-superuser `postgres` role: + * the domains ARE created, but they cannot hold data. Their CHECK calls + * `eql_v3_internal.ore_domain_unavailable()`, so the first INSERT raises + * + * ERROR: EQL: public.eql_v3_integer_ord_ore cannot be used on this platform: + * the EQL installer could not create the ORE operator class + * HINT: Use public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord + * (ordering) or public.eql_v3_integer_ord_ope (ordering) instead. + * + * The same INSERT succeeds on plain Postgres as a superuser. So ORE is not + * silently wrong on managed Postgres — it is loudly unusable, which is the right + * behaviour and means no query can ever return wrong rows from an ORE column. + * + * A matrix that must pass on both a superuser and a managed database therefore + * cannot cover them: the seed INSERT fails on one of the two. ORE gets a + * superuser-only suite instead. + * + * (The OPE-backed `_ord` domains have no such split. `eql_v3_internal.ope_cllw` + * is a domain over `bytea`, so it orders via the native btree everywhere, and + * the Supabase adapter sorts by it through the jsonb path `col->>op`.) + */ +const ORE_DEFERRED = + 'block-ORE columns cannot hold data on managed Postgres (domain CHECK raises ore_domain_unavailable); covered by a superuser-only follow-up suite' + +export const V3_MATRIX = { + // integer + 'public.eql_v3_integer': { + builder: types.Integer, + ColumnClass: EncryptedIntegerColumn, + castAs: 'number', + capabilities: STORAGE, + indexes: NONE, + samples: INTEGER_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_integer_eq': { + builder: types.IntegerEq, + ColumnClass: EncryptedIntegerEqColumn, + castAs: 'number', + capabilities: EQ, + indexes: UNIQUE_IDX, + samples: INTEGER_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_integer_ord_ore': { + builder: types.IntegerOrdOre, + ColumnClass: EncryptedIntegerOrdOreColumn, + castAs: 'number', + capabilities: ORD, + indexes: ORE_IDX, + samples: INTEGER_S, + errorSamples: NUM_ERR, + deferred: ORE_DEFERRED, + }, + 'public.eql_v3_integer_ord': { + builder: types.IntegerOrd, + ColumnClass: EncryptedIntegerOrdColumn, + castAs: 'number', + capabilities: ORD, + indexes: OPE_IDX, + samples: INTEGER_S, + errorSamples: NUM_ERR, + }, + // smallint + 'public.eql_v3_smallint': { + builder: types.Smallint, + ColumnClass: EncryptedSmallintColumn, + castAs: 'number', + capabilities: STORAGE, + indexes: NONE, + samples: SMALLINT_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_smallint_eq': { + builder: types.SmallintEq, + ColumnClass: EncryptedSmallintEqColumn, + castAs: 'number', + capabilities: EQ, + indexes: UNIQUE_IDX, + samples: SMALLINT_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_smallint_ord_ore': { + builder: types.SmallintOrdOre, + ColumnClass: EncryptedSmallintOrdOreColumn, + castAs: 'number', + capabilities: ORD, + indexes: ORE_IDX, + samples: SMALLINT_S, + errorSamples: NUM_ERR, + deferred: ORE_DEFERRED, + }, + 'public.eql_v3_smallint_ord': { + builder: types.SmallintOrd, + ColumnClass: EncryptedSmallintOrdColumn, + castAs: 'number', + capabilities: ORD, + indexes: OPE_IDX, + samples: SMALLINT_S, + errorSamples: NUM_ERR, + }, + // bigint (int8) — native JS bigint round-trip on protect-ffi 0.28; ungated + 'public.eql_v3_bigint': { + builder: types.Bigint, + ColumnClass: EncryptedBigintColumn, + castAs: 'bigint', + capabilities: STORAGE, + indexes: NONE, + samples: BIGINT_S, + errorSamples: BIGINT_ERR, + }, + 'public.eql_v3_bigint_eq': { + builder: types.BigintEq, + ColumnClass: EncryptedBigintEqColumn, + castAs: 'bigint', + capabilities: EQ, + indexes: UNIQUE_IDX, + samples: BIGINT_S, + errorSamples: BIGINT_ERR, + }, + 'public.eql_v3_bigint_ord_ore': { + builder: types.BigintOrdOre, + ColumnClass: EncryptedBigintOrdOreColumn, + castAs: 'bigint', + capabilities: ORD, + indexes: ORE_IDX, + samples: BIGINT_S, + errorSamples: BIGINT_ERR, + deferred: ORE_DEFERRED, + }, + 'public.eql_v3_bigint_ord': { + builder: types.BigintOrd, + ColumnClass: EncryptedBigintOrdColumn, + castAs: 'bigint', + capabilities: ORD, + indexes: OPE_IDX, + samples: BIGINT_S, + errorSamples: BIGINT_ERR, + }, + // date + 'public.eql_v3_date': { + builder: types.Date, + ColumnClass: EncryptedDateColumn, + castAs: 'date', + capabilities: STORAGE, + indexes: NONE, + samples: DATE_S, + }, + 'public.eql_v3_date_eq': { + builder: types.DateEq, + ColumnClass: EncryptedDateEqColumn, + castAs: 'date', + capabilities: EQ, + indexes: UNIQUE_IDX, + samples: DATE_S, + }, + 'public.eql_v3_date_ord_ore': { + builder: types.DateOrdOre, + ColumnClass: EncryptedDateOrdOreColumn, + castAs: 'date', + capabilities: ORD, + indexes: ORE_IDX, + samples: DATE_S, + deferred: ORE_DEFERRED, + }, + 'public.eql_v3_date_ord': { + builder: types.DateOrd, + ColumnClass: EncryptedDateOrdColumn, + castAs: 'date', + capabilities: ORD, + indexes: OPE_IDX, + samples: DATE_S, + }, + // timestamp + 'public.eql_v3_timestamp': { + builder: types.Timestamp, + ColumnClass: EncryptedTimestampColumn, + castAs: 'timestamp', + capabilities: STORAGE, + indexes: NONE, + samples: TS_S, + }, + 'public.eql_v3_timestamp_eq': { + builder: types.TimestampEq, + ColumnClass: EncryptedTimestampEqColumn, + castAs: 'timestamp', + capabilities: EQ, + indexes: UNIQUE_IDX, + samples: TS_S, + }, + 'public.eql_v3_timestamp_ord_ore': { + builder: types.TimestampOrdOre, + ColumnClass: EncryptedTimestampOrdOreColumn, + castAs: 'timestamp', + capabilities: ORD, + indexes: ORE_IDX, + samples: TS_S, + deferred: ORE_DEFERRED, + }, + 'public.eql_v3_timestamp_ord': { + builder: types.TimestampOrd, + ColumnClass: EncryptedTimestampOrdColumn, + castAs: 'timestamp', + capabilities: ORD, + indexes: OPE_IDX, + samples: TS_S, + }, + // numeric + 'public.eql_v3_numeric': { + builder: types.Numeric, + ColumnClass: EncryptedNumericColumn, + castAs: 'number', + capabilities: STORAGE, + indexes: NONE, + samples: NUMERIC_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_numeric_eq': { + builder: types.NumericEq, + ColumnClass: EncryptedNumericEqColumn, + castAs: 'number', + capabilities: EQ, + indexes: UNIQUE_IDX, + samples: NUMERIC_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_numeric_ord_ore': { + builder: types.NumericOrdOre, + ColumnClass: EncryptedNumericOrdOreColumn, + castAs: 'number', + capabilities: ORD, + indexes: ORE_IDX, + samples: NUMERIC_S, + errorSamples: NUM_ERR, + deferred: ORE_DEFERRED, + }, + 'public.eql_v3_numeric_ord': { + builder: types.NumericOrd, + ColumnClass: EncryptedNumericOrdColumn, + castAs: 'number', + capabilities: ORD, + indexes: OPE_IDX, + samples: NUMERIC_S, + errorSamples: NUM_ERR, + }, + // text + 'public.eql_v3_text': { + builder: types.Text, + ColumnClass: EncryptedTextColumn, + castAs: 'string', + capabilities: STORAGE, + indexes: NONE, + samples: TEXT_S, + }, + 'public.eql_v3_text_eq': { + builder: types.TextEq, + ColumnClass: EncryptedTextEqColumn, + castAs: 'string', + capabilities: EQ, + indexes: UNIQUE_IDX, + samples: TEXT_S, + }, + 'public.eql_v3_text_match': { + builder: types.TextMatch, + ColumnClass: EncryptedTextMatchColumn, + castAs: 'string', + capabilities: MATCH_ONLY, + indexes: MATCH_IDX, + samples: TEXT_S, + }, + 'public.eql_v3_text_ord_ore': { + builder: types.TextOrdOre, + ColumnClass: EncryptedTextOrdOreColumn, + castAs: 'string', + capabilities: ORD, + indexes: TEXT_ORD_ORE_IDX, + samples: TEXT_ORE_S, + deferred: ORE_DEFERRED, + }, + 'public.eql_v3_text_ord': { + builder: types.TextOrd, + ColumnClass: EncryptedTextOrdColumn, + castAs: 'string', + capabilities: ORD, + indexes: TEXT_ORD_IDX, + samples: TEXT_ORE_S, + }, + 'public.eql_v3_text_search': { + builder: types.TextSearch, + ColumnClass: EncryptedTextSearchColumn, + castAs: 'string', + capabilities: FULL, + indexes: TEXT_SEARCH_IDX, + samples: TEXT_ORE_S, + }, + // boolean + 'public.eql_v3_boolean': { + builder: types.Boolean, + ColumnClass: EncryptedBooleanColumn, + castAs: 'boolean', + capabilities: STORAGE, + indexes: NONE, + samples: BOOLEAN_S, + }, + // real + 'public.eql_v3_real': { + builder: types.Real, + ColumnClass: EncryptedRealColumn, + castAs: 'number', + capabilities: STORAGE, + indexes: NONE, + samples: REAL_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_real_eq': { + builder: types.RealEq, + ColumnClass: EncryptedRealEqColumn, + castAs: 'number', + capabilities: EQ, + indexes: UNIQUE_IDX, + samples: REAL_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_real_ord_ore': { + builder: types.RealOrdOre, + ColumnClass: EncryptedRealOrdOreColumn, + castAs: 'number', + capabilities: ORD, + indexes: ORE_IDX, + samples: REAL_S, + errorSamples: NUM_ERR, + deferred: ORE_DEFERRED, + }, + 'public.eql_v3_real_ord': { + builder: types.RealOrd, + ColumnClass: EncryptedRealOrdColumn, + castAs: 'number', + capabilities: ORD, + indexes: OPE_IDX, + samples: REAL_S, + errorSamples: NUM_ERR, + }, + // double + 'public.eql_v3_double': { + builder: types.Double, + ColumnClass: EncryptedDoubleColumn, + castAs: 'number', + capabilities: STORAGE, + indexes: NONE, + samples: DOUBLE_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_double_eq': { + builder: types.DoubleEq, + ColumnClass: EncryptedDoubleEqColumn, + castAs: 'number', + capabilities: EQ, + indexes: UNIQUE_IDX, + samples: DOUBLE_S, + errorSamples: NUM_ERR, + }, + 'public.eql_v3_double_ord_ore': { + builder: types.DoubleOrdOre, + ColumnClass: EncryptedDoubleOrdOreColumn, + castAs: 'number', + capabilities: ORD, + indexes: ORE_IDX, + samples: DOUBLE_S, + errorSamples: NUM_ERR, + deferred: ORE_DEFERRED, + }, + 'public.eql_v3_double_ord': { + builder: types.DoubleOrd, + ColumnClass: EncryptedDoubleOrdColumn, + castAs: 'number', + capabilities: ORD, + indexes: OPE_IDX, + samples: DOUBLE_S, + errorSamples: NUM_ERR, + }, + + // Encrypted JSONB document. Excluded from the SCALAR family driver (that is + // what `deferred` marks here) — NOT unimplemented: JSON is fully covered by + // its own live suites (`json-crypto`, `json-contains`). It is queried by + // containment (the `@>` operator), not the eq/ord/match ops the scalar oracle + // models, so `runFamilySuite` cannot exercise it. The row still pins the built + // shape (`cast_as: 'json'` + the encrypted-JSONB index) and carries + // representative document samples. + 'public.eql_v3_json': { + builder: types.Json, + ColumnClass: EncryptedJsonColumn, + castAs: 'json', + capabilities: { + equality: false, + orderAndRange: false, + freeTextSearch: false, + searchableJson: true, + }, + indexes: { + ste_vec: { + prefix: 'enabled', + array_index_mode: { item: true, wildcard: true, position: false }, + mode: 'compat', + }, + }, + samples: [ + { user: 'ada@example.com', roles: ['admin', 'eng'], active: true }, + { user: 'grace@example.com', roles: ['eng'] }, + ], + deferred: + 'json is covered by dedicated live suites (json-crypto, json-contains), ' + + 'not the scalar op-matrix: it is queried by containment, not eq/ord/match', + }, +} as const satisfies Record diff --git a/packages/test-kit/src/env.ts b/packages/test-kit/src/env.ts new file mode 100644 index 000000000..cb68fe83d --- /dev/null +++ b/packages/test-kit/src/env.ts @@ -0,0 +1,120 @@ +import { existsSync } from 'node:fs' +import { homedir } from 'node:os' +import { join } from 'node:path' + +/** + * Integration suites FAIL when they are not configured. They never skip. + * + * The suites they replace were gated by `describe.skipIf(...)`, which turns a + * missing credential into a silent whole-suite skip on a green job — the exact + * failure `live-coverage-guard.test.ts` exists to paper over. Throwing removes + * the need for that guard: an unconfigured run is red, and the message says how + * to fix it. + */ + +export type Requirement = 'cipherstash' | 'database' | 'pgrest' + +/** Every variable protect-ffi's `AutoStrategy` needs to authenticate from the environment. */ +const CS_VARS = [ + 'CS_WORKSPACE_CRN', + 'CS_CLIENT_ID', + 'CS_CLIENT_KEY', + 'CS_CLIENT_ACCESS_KEY', +] as const + +/** True when `stash auth login` has written a device profile. */ +function hasProfile(): boolean { + return existsSync(join(homedir(), '.cipherstash')) +} + +/** + * CipherStash credentials resolve from EITHER all four `CS_*` variables OR a + * local `~/.cipherstash` profile written by `stash auth login`. A developer who + * has logged in once needs no environment; CI, which has no profile, supplies + * the vars. + * + * A PARTIALLY configured environment is neither, and is rejected. Accepting it + * (as an earlier version did, on the presence of `CS_WORKSPACE_CRN` alone) let a + * rotated or cleared secret through the gate, and the run then failed once per + * test with `[encryption]: Not authenticated` — which names nothing and points + * nowhere. That is precisely the "fail loudly, and say how to fix it" contract + * this module exists to keep. + * + * The partial case is not merely under-configured, it is ambiguous: with a + * profile on disk it is unclear whether the caller meant to override one field + * or to use the environment wholesale. Refusing to guess is the honest answer. + */ +function cipherstashHint(): string | null { + const missing = CS_VARS.filter((name) => !process.env[name]) + + // Fully configured from the environment. Any profile is irrelevant. + if (missing.length === 0) return null + + // Nothing in the environment: the profile is the intended source. + if (missing.length === CS_VARS.length && hasProfile()) return null + + const preamble = + missing.length === CS_VARS.length + ? 'CipherStash credentials: none are configured.' + : `CipherStash credentials are PARTIALLY configured — missing ${missing.join(', ')}.\n` + + ' A partial environment is rejected rather than half-used: it would otherwise\n' + + ' fail later with "[encryption]: Not authenticated", which names nothing.' + + return ( + `${preamble}\n` + + ` Either set all four (${CS_VARS.join(', ')}),\n` + + ' or unset them all and run `stash auth login` once (writes ~/.cipherstash,\n' + + ' which AutoStrategy picks up).' + ) +} + +const HINTS: Record string | null> = { + cipherstash: cipherstashHint, + + database: () => + process.env['DATABASE_URL'] + ? null + : 'DATABASE_URL. Start a database and point at it:\n' + + ' docker compose -f local/docker-compose.postgres.yml up -d --wait\n' + + ' export DATABASE_URL=postgres://cipherstash:password@localhost:55432/cipherstash\n' + + ' ...or, for the Supabase variant:\n' + + ' docker compose -f local/docker-compose.supabase.yml up -d --wait\n' + + ' export DATABASE_URL=postgres://postgres:password@localhost:55433/postgres', + + pgrest: () => + process.env['PGRST_URL'] + ? null + : 'PGRST_URL. The Supabase adapter speaks PostgREST, not Postgres:\n' + + ' docker compose -f local/docker-compose.supabase.yml up -d --wait\n' + + ' export PGRST_URL=http://localhost:55430', +} + +/** + * Throw unless every requirement is satisfied, naming all of them at once — a + * developer fixing one variable at a time, one failed run at a time, is the + * thing this is trying to avoid. + */ +export function requireIntegrationEnv(requires: readonly Requirement[]): void { + const missing = requires + .map((requirement) => HINTS[requirement]()) + .filter((hint): hint is string => hint !== null) + + if (missing.length === 0) return + + throw new Error( + `Integration suite cannot run — missing configuration:\n\n - ${missing.join('\n\n - ')}\n\n` + + 'This suite FAILS rather than skips: a green skip would hide a real regression.', + ) +} + +/** The database URL, having asserted it exists. */ +export function databaseUrl(): string { + requireIntegrationEnv(['database']) + return process.env['DATABASE_URL'] as string +} + +/** The PostgREST base URL, having asserted it exists. */ +export function pgrestUrl(): string { + requireIntegrationEnv(['pgrest']) + return process.env['PGRST_URL'] as string +} diff --git a/packages/test-kit/src/families.ts b/packages/test-kit/src/families.ts new file mode 100644 index 000000000..4ba86969a --- /dev/null +++ b/packages/test-kit/src/families.ts @@ -0,0 +1,122 @@ +import { + type DomainSpec, + deferredReason, + type EqlV3TypeName, + eqlTypeSlug, + isCovered, + typedEntries, + V3_MATRIX, +} from './catalog.ts' + +/** + * Integration suites are split one file per plaintext family, not one per + * domain (39 files per adapter) nor one per capability tier (which buries the + * plaintext axis that actually drives the samples and the oracle). A family is + * the set of domains sharing a plaintext type and sample set — `integer`, + * `integer_eq`, `integer_ord`, `integer_ord_ore` — so one file seeds one table + * and exercises every capability tier that plaintext supports. + */ +export type FamilyName = + | 'integer' + | 'smallint' + | 'bigint' + | 'real-double' + | 'numeric' + | 'date' + | 'timestamp' + | 'text' + | 'boolean' + | 'json' + +/** + * The bare-domain prefixes each family owns. `real-double` pairs two prefixes + * because both are IEEE floats over the same sample set; every other family is + * one prefix. + * + * Matched against the BARE domain (`integer_ord`), not the slug: `eqlTypeSlug` + * strips only the `public.` schema, so a slug is `eql_v3_integer_ord`. The slug + * stays the physical column name, matching the existing matrix suites. + */ +const FAMILY_PREFIXES: Readonly> = { + integer: ['integer'], + smallint: ['smallint'], + bigint: ['bigint'], + 'real-double': ['real', 'double'], + numeric: ['numeric'], + date: ['date'], + timestamp: ['timestamp'], + text: ['text'], + boolean: ['boolean'], + // `json` is here only for coverage accounting — its one domain (`eql_v3_json`) + // is marked `deferred`, meaning "not run by the scalar op-matrix", because JSON + // is queried by containment (`@>`), not the eq/ord/match ops the oracle models. + // It is NOT unimplemented: dedicated live suites (`json-crypto`, `json-contains`) + // cover it. (Contrast the ORE domains, also `deferred` but because their opclass + // is superuser-only and cannot run on managed Postgres.) + json: ['json'], +} + +export const FAMILY_NAMES = Object.keys(FAMILY_PREFIXES) as FamilyName[] + +/** One family column: its physical column name, its domain, and its catalog row. */ +export type FamilyDomain = Readonly<{ + /** Physical column name in the test table, e.g. `eql_v3_integer_ord`. */ + slug: string + /** The domain without its `eql_v3_` prefix, e.g. `integer_ord`. Drives family matching. */ + bare: string + eqlType: EqlV3TypeName + spec: DomainSpec +}> + +/** `public.eql_v3_integer_ord` → `integer_ord`. */ +function bareDomain(eqlType: EqlV3TypeName | string): string { + return eqlTypeSlug(eqlType).replace(/^eql_v3_/, '') +} + +/** + * `integer` must not swallow `smallint`, and `date` must not swallow + * `timestamp` — but `text` legitimately owns `text_search`. Match on the prefix + * followed by end-of-string or `_`, so `date` claims `date` and `date_ord` + * while `timestamp*` stays with `timestamp`. A naive `startsWith` would not. + */ +function belongsTo(bare: string, prefix: string): boolean { + return bare === prefix || bare.startsWith(`${prefix}_`) +} + +function rowsMatching( + family: FamilyName, + covered: boolean, +): Array<[EqlV3TypeName, DomainSpec]> { + const prefixes = FAMILY_PREFIXES[family] + return typedEntries(V3_MATRIX) + .filter(([, spec]) => isCovered(spec) === covered) + .filter(([eqlType]) => + prefixes.some((p) => belongsTo(bareDomain(eqlType), p)), + ) +} + +/** + * Every domain in a family that the integration matrix covers, in catalog order. + * Deferred domains (see {@link DomainSpec.deferred}) are excluded here rather + * than skipped per-test, so a family file cannot accidentally assert against a + * domain the database does not have. + */ +export function domainsForFamily(family: FamilyName): FamilyDomain[] { + return rowsMatching(family, true).map(([eqlType, spec]) => ({ + slug: eqlTypeSlug(eqlType), + bare: bareDomain(eqlType), + eqlType, + spec, + })) +} + +/** Domains a family declares but the matrix skips, with the reason. Reported by the driver. */ +export function deferredForFamily( + family: FamilyName, +): Array<{ slug: string; bare: string; reason: string }> { + return rowsMatching(family, false).map(([eqlType, spec]) => ({ + slug: eqlTypeSlug(eqlType), + bare: bareDomain(eqlType), + reason: deferredReason(spec) ?? '', + })) +} diff --git a/packages/test-kit/src/index.ts b/packages/test-kit/src/index.ts new file mode 100644 index 000000000..8b359f78e --- /dev/null +++ b/packages/test-kit/src/index.ts @@ -0,0 +1,68 @@ +/** + * Shared EQL v3 test harness. + * + * The domain catalog is the single source of truth: it is + * `satisfies Record` over the real column union, so + * adding a domain to the SDK fails this package's typecheck until a row exists. + * Everything else here derives from it — which operations a domain must answer, + * which it must reject, and what the expected rows are. + * + * Consumed as TypeScript source (no build). See `vitest.shared.ts` at the repo + * root for the runtime aliases and `tsconfig.json` here for the compile-time ones. + * + * This barrel MUST NOT import `vitest`, directly or transitively. Vitest's + * `globalSetup` runs in a different context from the test workers, and a + * `vitest` import reached from there fails with "Vitest failed to access its + * internal state". `global-setup.ts` imports this barrel, so the test driver + * lives behind its own subpath: `@cipherstash/test-kit/suite`. + */ + +export type { IntegrationAdapter } from './adapter.ts' +export { + type DomainSpec, + deferredReason, + EQL_V3_DOMAIN_SCHEMA, + type EqlV3TypeName, + eqlTypeSlug, + isCovered, + typedEntries, + V3_MATRIX, +} from './catalog.ts' +export { + databaseUrl, + pgrestUrl, + type Requirement, + requireIntegrationEnv, +} from './env.ts' +export { + deferredForFamily, + domainsForFamily, + FAMILY_NAMES, + type FamilyDomain, + type FamilyName, +} from './families.ts' +export { type DbVariant, dbVariant, installEqlV3 } from './install.ts' +export { needleFor } from './needle-for.ts' +export { + negativeOps, + type Plain, + positiveOps, + type QueryOp, + type QueryOpKind, +} from './ops.ts' +export { + comparePlain, + expectedKeysFor, + matchesPlain, + plainValue, + sortedKeysFor, +} from './oracle.ts' +export { unwrapResult } from './results.ts' +export { + NULL_ROW_KEY, + type PlainRow, + planRows, + planTable, + type RowPlan, + type TableSpec, +} from './rows.ts' diff --git a/packages/test-kit/src/install.ts b/packages/test-kit/src/install.ts new file mode 100644 index 000000000..cbb528fc0 --- /dev/null +++ b/packages/test-kit/src/install.ts @@ -0,0 +1,84 @@ +import { execFile } from 'node:child_process' +import { existsSync } from 'node:fs' +import { dirname, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' +import { promisify } from 'node:util' + +const execFileAsync = promisify(execFile) + +/** `packages/test-kit/src` → repo root. */ +const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../../..') +const STASH_BIN = resolve(REPO_ROOT, 'packages/cli/dist/bin/stash.js') + +export type DbVariant = 'postgres' | 'supabase' + +/** + * Which database the integration suite is pointed at. + * + * Set `CS_IT_DB_VARIANT` explicitly. The `PGRST_URL` fallback exists only for a + * developer running one suite by hand, and it is a guess: it once inferred + * `postgres` for the Drizzle job running against `supabase/postgres`, because + * that job needs no PostgREST and leaves the variable unset. The consequence was + * silent — EQL installed without `--supabase`, so the role grants were never + * applied and the grants test skipped, while the suite passed because Drizzle + * connects as `postgres` rather than as `anon`. + * + * The variant decides how EQL is installed. It must not be a guess in CI. + */ +export function dbVariant(): DbVariant { + const explicit = process.env['CS_IT_DB_VARIANT'] + if (explicit === 'postgres' || explicit === 'supabase') return explicit + return process.env['PGRST_URL'] ? 'supabase' : 'postgres' +} + +/** + * Install EQL v3 by running the real `stash eql install`, not by applying the + * SQL bundle directly. + * + * The installer is a shipped product surface — it vendors the bundle, verifies + * it against the release manifest, decides what to skip on a non-superuser, and + * applies the Supabase role grants. Driving it here means an installer + * regression fails the integration jobs instead of hiding behind a test-only + * code path that reimplements half of it. + * + * Notes on the flags: + * - `--supabase` applies the `eql_v3` AND `eql_v3_internal` grants to + * anon/authenticated/service_role. The SECURITY INVOKER extractors need both. + * - `--direct` is required alongside it: `--supabase` alone prompts for an + * install mode (migration vs direct) and would hang a CI job. + * - Verified against `supabase/postgres:17.4.1.048` as the NON-superuser + * `postgres` role: no superuser connection is needed. + */ +export async function installEqlV3( + databaseUrl: string, + variant: DbVariant = dbVariant(), +): Promise { + if (!existsSync(STASH_BIN)) { + throw new Error( + `The stash CLI is not built (${STASH_BIN} is missing).\n` + + 'The integration suites install EQL v3 through the real CLI. Build it first:\n' + + ' pnpm exec turbo run build --filter stash', + ) + } + + const args = ['eql', 'install', '--eql-version', '3'] + if (variant === 'supabase') args.push('--supabase', '--direct') + args.push('--database-url', databaseUrl) + + try { + await execFileAsync(process.execPath, [STASH_BIN, ...args], { + cwd: REPO_ROOT, + // The CLI is a clack TUI. Without a TTY it takes its non-interactive + // paths, which is what we want; `CI` makes that explicit. + env: { ...process.env, CI: '1' }, + maxBuffer: 32 * 1024 * 1024, + }) + } catch (cause) { + const detail = cause instanceof Error ? cause.message : String(cause) + throw new Error( + `stash eql install --eql-version 3${variant === 'supabase' ? ' --supabase --direct' : ''} failed.\n` + + 'This is the real installer, so a failure here is a real bug — do not work around it.\n' + + detail, + ) + } +} diff --git a/packages/test-kit/src/integration/clerk.ts b/packages/test-kit/src/integration/clerk.ts new file mode 100644 index 000000000..44fc4254e --- /dev/null +++ b/packages/test-kit/src/integration/clerk.ts @@ -0,0 +1,54 @@ +import { createClerkClient } from '@clerk/backend' + +/** + * A `getJwt` provider for `OidcFederationStrategy` that mints a fresh Clerk + * machine-to-machine token (JWT) on demand. + * + * Why this instead of a stored `USER_JWT`: the strategy re-invokes `getJwt` on + * every (re-)federation and CTS issues no refresh token, so a short-lived, + * freshly-minted token self-heals on expiry — nothing long-lived is ever kept + * in an env var or a CI secret. The only secret is `CLERK_MACHINE_TOKEN`, a + * rotatable machine key. + * + * The federated identity is the Clerk machine (`CTS|CS|mch_…`), stable across + * encrypt and decrypt. Pass a different `tokenEnvVar` (e.g. a second machine's + * `CLERK_MACHINE_TOKEN_B`) to federate as a DISTINCT identity — that is what the + * cross-identity test uses to prove a row sealed under one machine does not + * decrypt under another. + * + * The workspace named by `CS_WORKSPACE_CRN` must have this Clerk instance + * registered on its OIDC-providers page, or `/api/authorise` rejects the token. + */ +export function clerkJwtProvider( + tokenEnvVar = 'CLERK_MACHINE_TOKEN', +): () => Promise { + const machineSecretKey = process.env[tokenEnvVar] + if (!machineSecretKey) { + throw new Error( + `Integration suite cannot run — missing ${tokenEnvVar} (a Clerk machine ` + + 'secret key, ak_...). Its Clerk instance must be registered on the ' + + 'CS_WORKSPACE_CRN workspace OIDC-providers page. This suite FAILS rather ' + + 'than skips: a green skip would hide a real regression.', + ) + } + + // `createToken` authenticates with `machineSecretKey`; `createClerkClient` + // still wants a `secretKey` string at construction that this path never uses. + const clerk = createClerkClient({ + secretKey: process.env['CLERK_SECRET_KEY'] ?? 'sk_test_placeholder', + }) + + return async () => { + const m2m = await clerk.m2m.createToken({ + machineSecretKey, + tokenFormat: 'jwt', + secondsUntilExpiration: 300, + }) + if (typeof m2m.token !== 'string') { + throw new Error( + 'Clerk M2M createToken did not return a JWT — enable the JWT token format for the machine in the Clerk Dashboard.', + ) + } + return m2m.token + } +} diff --git a/packages/test-kit/src/integration/config.ts b/packages/test-kit/src/integration/config.ts new file mode 100644 index 000000000..4e224c87e --- /dev/null +++ b/packages/test-kit/src/integration/config.ts @@ -0,0 +1,38 @@ +import { resolve } from 'node:path' + +/** + * Shared integration-suite vitest wiring, so the adapter packages' near-identical + * `integration/vitest.config.ts` files don't drift. The harness (`global-setup`, + * the no-skips reporter) lives beside this file in `@cipherstash/test-kit`. + * + * Each package still owns its own `defineConfig`, `resolve.alias` + * (`...sharedAlias, ...stackSourceAlias`), and `test.root` — only the harness + * paths and the shared `test.*` knobs come from here. + */ +const HERE = __dirname + +// Not `as const`: vitest's `test` config wants mutable `string[]` for +// globalSetup/reporters and the `'passed-only'` literal for `silent`; a blanket +// `as const` makes the arrays `readonly` and fails `defineConfig`'s overload. + +/** `globalSetup` (installs EQL v3) + the fail-on-skip reporter. */ +export const integrationHarness = { + globalSetup: [resolve(HERE, 'global-setup.ts')], + reporters: ['default', resolve(HERE, 'no-skips-reporter.ts')], +} + +/** + * The `test.*` knobs every integration suite shares: `@cipherstash/test-kit` must + * be inlined (it imports `vitest` and is externalized as out-of-root source); + * real crypto over the network needs generous timeouts; suites share one DB so no + * file parallelism; suppress passing-rejection ERROR noise; a fully-empty run is a + * failure, not a pass. + */ +export const integrationTestDefaults = { + server: { deps: { inline: [/packages\/test-kit/] } }, + testTimeout: 60_000, + hookTimeout: 180_000, + fileParallelism: false, + silent: 'passed-only' as const, + passWithNoTests: false, +} diff --git a/packages/test-kit/src/integration/global-setup.ts b/packages/test-kit/src/integration/global-setup.ts new file mode 100644 index 000000000..33b838289 --- /dev/null +++ b/packages/test-kit/src/integration/global-setup.ts @@ -0,0 +1,27 @@ +import { + databaseUrl, + dbVariant, + installEqlV3, + type Requirement, + requireIntegrationEnv, +} from '../index.ts' + +/** + * Fail fast, before a single container second is spent, and install EQL v3 once + * per run through the real `stash eql install`. + * + * Runs in Vitest's `globalSetup`, so a misconfigured run reports one clear error + * rather than the same error once per test file. + */ +export async function setup(): Promise { + const variant = dbVariant() + + // Every integration suite encrypts, so CipherStash credentials are always + // required. The Supabase variant additionally needs PostgREST — the adapter + // does not speak Postgres. + const requirements: Requirement[] = ['cipherstash', 'database'] + if (variant === 'supabase') requirements.push('pgrest') + requireIntegrationEnv(requirements) + + await installEqlV3(databaseUrl(), variant) +} diff --git a/packages/test-kit/src/integration/no-skips-reporter.ts b/packages/test-kit/src/integration/no-skips-reporter.ts new file mode 100644 index 000000000..4759905b2 --- /dev/null +++ b/packages/test-kit/src/integration/no-skips-reporter.ts @@ -0,0 +1,47 @@ +import type { Reporter, TestModule } from 'vitest/node' + +/** + * Fail the integration run if any test was skipped. + * + * A skipped test reads exactly like a passing one. Every silent hole this suite + * has found took that shape: `matches` never ran on `text_match` because its + * needle was `''`; the non-ASCII ORE needle test had zero cases after the OPE + * re-pin; the Supabase grants check quietly did not run for the Drizzle job + * because `dbVariant()` mis-inferred the database. In each case a green run + * reported coverage it did not have. + * + * So the integration suites carry no `skip`, no `todo`, no `runIf` and no + * `skipIf`. Environmental differences are asserted rather than skipped: a plain + * Postgres has no `anon` role, and that is a fact worth stating. Where a + * behaviour genuinely cannot be exercised — the block-ORE domains cannot hold + * data on managed Postgres — the domain is excluded from the matrix by the + * catalog's `deferred` field, and a separate, PASSING test asserts that the + * excluded set is exactly what it should be. + * + * The unit suites still skip (the `LIVE_*` gates), so this is scoped to the + * integration config rather than imposed repo-wide. + */ +export default class NoSkipsReporter implements Reporter { + private readonly skipped: string[] = [] + + onTestModuleEnd(testModule: TestModule): void { + for (const test of Array.from(testModule.children.allTests())) { + const result = test.result() + if (result.state === 'skipped') this.skipped.push(test.fullName) + } + } + + onTestRunEnd(): void { + if (this.skipped.length === 0) return + + const list = this.skipped.map((name) => ` - ${name}`).join('\n') + console.error( + `\n${this.skipped.length} test(s) were SKIPPED. The integration suites must not skip:\n` + + `${list}\n\n` + + 'A skipped test reads exactly like a passing one. Assert the environmental\n' + + "difference instead, or exclude the domain via the catalog's `deferred`\n" + + 'field and assert the excluded set separately.\n', + ) + process.exitCode = 1 + } +} diff --git a/packages/test-kit/src/needle-for.ts b/packages/test-kit/src/needle-for.ts new file mode 100644 index 000000000..240ef30ca --- /dev/null +++ b/packages/test-kit/src/needle-for.ts @@ -0,0 +1,35 @@ +// test-kit is an internal, source-only package that consumes stack through the +// `@/` alias (like `catalog.ts` does) — not through the published adapter seam. +// So we import `matchNeedleError` straight from `@/schema/match-defaults` rather +// than `@cipherstash/stack/adapter-kit`: the adapter-kit BARREL also re-exports +// `bulkModelsToEncryptedPgComposites` from `encryption/helpers`, and importing +// anything from that barrel drags the whole encryption/helpers → jsonb chain into +// test-kit's strict `tsc` graph (whose stricter options flag pre-existing loose +// types there). The published adapter packages, which have no `@/` alias, use the +// adapter-kit seam as intended; test-kit does not need it. +import { matchNeedleError } from '@/schema/match-defaults' +import type { V3_MATRIX } from './catalog' + +type MatrixSpec = (typeof V3_MATRIX)[keyof typeof V3_MATRIX] + +/** + * Pick a sample from a match domain that can actually be used as a `matches` + * needle. `sampleFor` is no good here — `TEXT_S[0]` is the empty string, which + * tokenizes to nothing and is rejected as unanswerable. + * + * Selection runs the production predicate rather than a length check of our + * own. A `sample.length >= 3` check would count UTF-16 code units where the + * guard counts codepoints, so an astral sample ('👍👍': 4 units, 2 codepoints) + * would be picked here and then thrown out by the guard, blaming the wrong + * line. It would also ignore a domain that raises its own `token_length`. + */ +export const needleFor = (spec: MatrixSpec): string => { + const match = 'match' in spec.indexes ? (spec.indexes.match ?? {}) : {} + const needle = spec.samples.find( + (sample) => typeof sample === 'string' && !matchNeedleError(sample, match), + ) + if (typeof needle !== 'string') { + throw new Error('no searchable sample for a match domain') + } + return needle +} diff --git a/packages/test-kit/src/ops.ts b/packages/test-kit/src/ops.ts new file mode 100644 index 000000000..b95a1b35d --- /dev/null +++ b/packages/test-kit/src/ops.ts @@ -0,0 +1,106 @@ +import type { QueryCapabilities } from '@cipherstash/stack/eql/v3' + +/** Every query operation an adapter can be asked to perform on an encrypted column. */ +export type QueryOpKind = + | 'eq' + | 'ne' + | 'in' + | 'notIn' + | 'gt' + | 'gte' + | 'lt' + | 'lte' + | 'between' + | 'notBetween' + | 'matches' + | 'order' + | 'isNull' + | 'isNotNull' + +export type Plain = string | number | bigint | boolean | Date + +export type QueryOp = + | { + kind: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' + column: string + value: Plain + } + | { + kind: 'in' | 'notIn' + column: string + values: readonly Plain[] + /** + * Supabase only: drive the raw `.filter(col, 'in', […])` path instead of + * `.in()`. They are different code paths — the raw path reached `in` with + * no element-split and encrypted the whole list as one term — so both + * must be proven against the same oracle. + */ + asRawFilter?: boolean + } + | { kind: 'between' | 'notBetween'; column: string; lo: Plain; hi: Plain } + | { kind: 'matches'; column: string; needle: string } + | { kind: 'order'; column: string; direction: 'asc' | 'desc' } + | { kind: 'isNull' | 'isNotNull'; column: string } + +/** + * Which operations each capability unlocks. This table is the ONLY place the + * mapping lives: the positive tests and the rejection tests are both derived + * from it, so flipping a capability flag in the catalog turns a passing + * rejection into a failing query (and vice versa) rather than silently + * disagreeing with the SDK. + * + * `orderAndRange` implies equality in the SDK's presets, but that is a property + * of the CATALOG rows (`ORD` sets `equality: true`), not of this table — do not + * encode the implication twice. + */ +const OPS_BY_CAPABILITY = { + equality: ['eq', 'ne', 'in', 'notIn'], + orderAndRange: ['gt', 'gte', 'lt', 'lte', 'between', 'notBetween', 'order'], + freeTextSearch: ['matches'], + // json domains are `deferred` from this driver (ste_vec doesn't fit the scalar + // oracle) and covered by a dedicated suite (`json-contains`, which calls the + // adapter's exact `contains()` directly), so this entry only satisfies the + // capability-keyed type — it gates no matrix run. `matches` is a placeholder. + searchableJson: ['matches'], +} as const satisfies Record + +/** + * Null presence is structural, not cryptographic: a NULL plaintext is stored as + * a SQL NULL on every domain, including storage-only ones. So `isNull` / + * `isNotNull` are never capability-gated, and never appear in the rejection set. + */ +const STRUCTURAL_OPS: readonly QueryOpKind[] = ['isNull', 'isNotNull'] + +function enabledBy(kind: QueryOpKind, caps: QueryCapabilities): boolean { + return ( + Object.keys(OPS_BY_CAPABILITY) as Array + ).some( + (cap) => + caps[cap] && + (OPS_BY_CAPABILITY[cap] as readonly QueryOpKind[]).includes(kind), + ) +} + +/** Operations this adapter supports AND this domain's capabilities allow. Must succeed. */ +export function positiveOps( + caps: QueryCapabilities, + supported: ReadonlySet, +): Set { + return new Set([...supported].filter((kind) => enabledBy(kind, caps))) +} + +/** + * Operations this adapter supports but this domain's capabilities forbid. Must + * be rejected — by a compile error in typed usage, and by a thrown error here. + * Structural ops are excluded: they are legal on every domain. + */ +export function negativeOps( + caps: QueryCapabilities, + supported: ReadonlySet, +): Set { + return new Set( + [...supported].filter( + (kind) => !enabledBy(kind, caps) && !STRUCTURAL_OPS.includes(kind), + ), + ) +} diff --git a/packages/test-kit/src/oracle.ts b/packages/test-kit/src/oracle.ts new file mode 100644 index 000000000..bc05a529c --- /dev/null +++ b/packages/test-kit/src/oracle.ts @@ -0,0 +1,105 @@ +import type { DomainSpec } from './catalog.ts' +import type { Plain } from './ops.ts' + +/** + * The expected result of every query is computed from the PLAINTEXT, never + * restated as a literal. Lifted from `drizzle-v3/operators-live-pg.test.ts`, + * which is where these rules were originally worked out; the comments are the + * load-bearing part. + */ + +/** + * Row `i` of a domain takes `samples[min(i, len - 1)]`. Domains with fewer + * distinct samples than there are rows therefore REUSE their last value, which + * is deliberate: it produces ties, so ordering tie-breaks and range boundaries + * are exercised rather than vacuously satisfied. + */ +export function plainValue( + spec: DomainSpec, + rowKeys: readonly string[], + rowKey: string, +): Plain { + const index = rowKeys.indexOf(rowKey) + if (index < 0) throw new Error(`Unknown row key: ${rowKey}`) + const sample = spec.samples[Math.min(index, spec.samples.length - 1)] + if (sample === undefined) { + throw new Error(`Domain has no samples for row ${rowKey}`) + } + // Samples widened to include `JsonValue` for the (deferred) json domain; the + // scalar oracle is only ever called on covered scalar domains, so this narrows + // safely. + return sample as Plain +} + +export function comparePlain(left: Plain, right: Plain): number { + if (left instanceof Date && right instanceof Date) { + return left.getTime() - right.getTime() + } + if (typeof left === 'number' && typeof right === 'number') { + return left - right + } + // bigint order domains (`bigint_ord`/`bigint_ord_ore`) carry i64 samples + // beyond Number.MAX_SAFE_INTEGER, so they must be compared as bigints — the + // subtraction is narrowed to -1/0/1 because callers expect a `number`. + if (typeof left === 'bigint' && typeof right === 'bigint') { + return left < right ? -1 : left > right ? 1 : 0 + } + if (typeof left === 'string' && typeof right === 'string') { + // eql_v3 text ordering is BYTEWISE, not locale-collated: the oracle must + // model codepoint order, not `localeCompare` (which folds case, reorders + // punctuation vs letters, and is locale-dependent). Text samples must stay + // ASCII/unambiguous so UTF-16 code-unit order == the byte order the DB + // actually sorts by. + return left < right ? -1 : left > right ? 1 : 0 + } + if (typeof left === 'boolean' && typeof right === 'boolean') { + return Number(left) - Number(right) + } + throw new Error( + `Unsupported ordered values: ${String(left)}, ${String(right)}`, + ) +} + +/** Row keys whose plaintext satisfies `predicate`. The NULL row is never included. */ +export function expectedKeysFor( + spec: DomainSpec, + rowKeys: readonly string[], + predicate: (value: Plain) => boolean, +): string[] { + return rowKeys.filter((rowKey) => + predicate(plainValue(spec, rowKeys, rowKey)), + ) +} + +/** + * Oracle for the encrypted ORDER BY. Domains with fewer samples than rows give + * two rows equal values, so the comparison alone does not determine the row + * order — ties break on `rowKey` ascending, which the query mirrors with a + * secondary `ORDER BY row_key`. Without that both sides would be arbitrary and + * the test would flake rather than prove ordering. + */ +export function sortedKeysFor( + spec: DomainSpec, + rowKeys: readonly string[], + direction: 'asc' | 'desc', +): string[] { + return [...rowKeys].sort((left, right) => { + const cmp = comparePlain( + plainValue(spec, rowKeys, left), + plainValue(spec, rowKeys, right), + ) + if (cmp !== 0) return direction === 'asc' ? cmp : -cmp + return left < right ? -1 : left > right ? 1 : 0 + }) +} + +/** + * The `matches` (free-text) oracle. The match index downcases and tokenizes into + * 3-grams with `include_original: true`, so a needle matches iff it appears in + * the downcased value — with the caveat that a needle longer than the tokenizer + * window contributes a whole-value token no stored trigram supplies. Family + * files choose needles accordingly; this models the plaintext side only. + */ +export function matchesPlain(value: Plain, needle: string): boolean { + return String(value).toLowerCase().includes(needle.toLowerCase()) +} diff --git a/packages/test-kit/src/results.ts b/packages/test-kit/src/results.ts new file mode 100644 index 000000000..4981a2774 --- /dev/null +++ b/packages/test-kit/src/results.ts @@ -0,0 +1,16 @@ +/** + * Unwrap a `@byteslice/result`-shaped `{ data } | { failure }` value in a test, + * throwing the failure message on the error arm. The integration suites and the + * ported live suites all assert on the success arm, so this keeps the + * `if (result.failure) throw` boilerplate in one place rather than re-declaring + * a local `unwrap()` per file. + */ +export function unwrapResult(result: { + data?: T + failure?: { message: string } +}): T { + if (result.failure) { + throw new Error(result.failure.message) + } + return result.data as T +} diff --git a/packages/test-kit/src/rows.ts b/packages/test-kit/src/rows.ts new file mode 100644 index 000000000..f42795b78 --- /dev/null +++ b/packages/test-kit/src/rows.ts @@ -0,0 +1,106 @@ +import type { FamilyDomain, FamilyName } from './families.ts' +import type { Plain } from './ops.ts' +import { plainValue } from './oracle.ts' + +/** The table one family file creates: one column per covered domain in the family. */ +export type TableSpec = Readonly<{ + /** Unique per run so concurrent suites and reruns never collide. */ + name: string + runId: string + columns: readonly FamilyDomain[] +}> + +export type PlainRow = Readonly<{ + rowKey: string + runId: string + /** Plaintext per column slug. Empty on the NULL row. */ + values: Readonly> +}> + +export type RowPlan = Readonly<{ + /** Row keys carrying values, in ascending order — the oracle's domain. */ + rowKeys: readonly string[] + byKey: Readonly> + /** Inserted one at a time, through the adapter's `encryptModel` path. */ + singleKeys: readonly string[] + /** Inserted as one array, through the adapter's `bulkEncryptModels` path. */ + bulkKeys: readonly string[] + /** Every encrypted column NULL. Exercises `isNull`/`isNotNull` on every domain. */ + nullRow: PlainRow +}> + +/** + * Three value rows minimum, so a predicate that over-matches by one row is + * detectable; four when any domain in the family has that many distinct samples, + * so the extra sample (usually a type bound) reaches the database. More rows buy + * nothing: the oracle already covers ties via the `samples[min(i, len-1)]` reuse. + */ +const MIN_VALUE_ROWS = 3 +const MAX_VALUE_ROWS = 4 + +const ROW_KEYS = ['a', 'b', 'c', 'd'] as const +const NULL_ROW_KEY = 'null' + +function valueRowCount(domains: readonly FamilyDomain[]): number { + const widest = Math.max(...domains.map((d) => d.spec.samples.length)) + return Math.min(Math.max(widest, MIN_VALUE_ROWS), MAX_VALUE_ROWS) +} + +/** + * A table name unique to this family and run. Postgres identifiers cap at 63 + * bytes and the run id is a caller-supplied short hex string, so this stays well + * inside the limit for every family name. + */ +export function planTable( + family: FamilyName, + domains: readonly FamilyDomain[], + runId: string, +): TableSpec { + if (domains.length === 0) { + throw new Error( + `Family "${family}" has no covered domains — check FAMILY_PREFIXES and the catalog's deferred rows`, + ) + } + return { + name: `v3_it_${family.replace(/-/g, '_')}_${runId}`, + runId, + columns: domains, + } +} + +/** + * Seed rows plus the single/bulk split. + * + * The halves are DISJOINT and interleaved (`a`,`c` single; `b`,`d` bulk) so that + * any per-domain predicate matching more than one row necessarily spans both + * encryption paths. That is what turns "the bulk path mangled a row" into a red + * test rather than a coincidence — before this, the Supabase adapter's array + * insert (`bulkEncryptModels`) and the Drizzle single insert (`encryptModel`) + * were each untested on their respective sides. + */ +export function planRows( + domains: readonly FamilyDomain[], + runId: string, +): RowPlan { + const count = valueRowCount(domains) + const rowKeys = ROW_KEYS.slice(0, count) + + const byKey: Record = {} + for (const rowKey of rowKeys) { + const values: Record = {} + for (const domain of domains) { + values[domain.slug] = plainValue(domain.spec, rowKeys, rowKey) + } + byKey[rowKey] = { rowKey, runId, values } + } + + return { + rowKeys, + byKey, + singleKeys: rowKeys.filter((_, i) => i % 2 === 0), + bulkKeys: rowKeys.filter((_, i) => i % 2 === 1), + nullRow: { rowKey: NULL_ROW_KEY, runId, values: {} }, + } +} + +export { NULL_ROW_KEY } diff --git a/packages/test-kit/src/run-family-suite.ts b/packages/test-kit/src/run-family-suite.ts new file mode 100644 index 000000000..6cca1ca2e --- /dev/null +++ b/packages/test-kit/src/run-family-suite.ts @@ -0,0 +1,380 @@ +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import type { IntegrationAdapter } from './adapter.ts' +import type { DomainSpec } from './catalog.ts' +import { + deferredForFamily, + domainsForFamily, + type FamilyName, +} from './families.ts' +import { negativeOps, type Plain, positiveOps, type QueryOp } from './ops.ts' +import { + comparePlain, + expectedKeysFor, + matchesPlain, + plainValue, + sortedKeysFor, +} from './oracle.ts' +import { planRows, planTable } from './rows.ts' + +/** + * The shared driver. One family file per adapter is three lines; everything a + * test asserts is derived from the domain's catalog row, so Drizzle and Supabase + * cannot quietly cover different operations while both read as "comprehensive". + * + * What is asserted, per domain: + * - every operation the domain's capabilities allow, over a RANGE of values, + * against a plaintext oracle; + * - every operation they forbid, rejected; + * - that both the single-encrypt and bulk-encrypt insert paths produced + * queryable ciphertext. + */ + +/** Distinct sample values for a domain, in ascending order, deduplicated by `comparePlain`. */ +function distinctValues(spec: DomainSpec, rowKeys: readonly string[]): Plain[] { + const values = rowKeys.map((key) => plainValue(spec, rowKeys, key)) + const sorted = [...values].sort(comparePlain) + return sorted.filter( + (value, i) => i === 0 || comparePlain(value, sorted[i - 1] as Plain) !== 0, + ) +} + +/** A needle to search for, and what it is meant to discriminate. */ +type Needle = Readonly<{ label: string; needle: string }> + +/** + * The needle set for a `freeTextSearch` domain. + * + * A single 3-character needle is NOT sufficient coverage, and the reason is + * subtle enough to be worth stating. + * + * The match index tokenizes into downcased 3-grams. `include_original: true` + * additionally blooms the WHOLE value as one token. Storage wants that; a QUERY + * operand must not have it, or the needle's bloom carries a whole-needle token + * that the haystack's bloom cannot contain, and every strict-substring search + * returns nothing. + * + * Both v3 adapters build match operands with `encrypt` — the full storage + * envelope — not `encryptQuery`, because PostgREST cannot cast a filter value to + * `eql_v3.query_*`. So both are structurally exposed to exactly that. Today it + * is masked: protect-ffi ignores `include_original` outright, so neither the + * stored value nor the operand carries the whole-value token. Two bugs cancel. + * The day protect-ffi honours the flag, substring search breaks — silently, by + * returning no rows. See cipherstash/stack#615. + * + * A 3-character needle cannot see any of this: its whole-value token IS a + * trigram, so it matches either way. That is the degenerate case. The + * discriminating needle is a strict substring LONGER than `token_length`, taken + * from the interior so no prefix-specific shortcut can satisfy it. + * + * THROWS rather than skipping when no sample qualifies: a `freeTextSearch` + * domain whose catalog row cannot produce a needle is a catalog bug, and must be + * loud. (This previously derived the needle from the domain's MINIMUM value — + * the empty string for text — so `text_match`, the only match-only domain, + * silently skipped the only test of its only capability.) + */ +function needlesFrom(values: readonly Plain[]): Needle[] { + const longest = [...values] + .map(String) + .sort((left, right) => right.length - left.length)[0] + + if (longest === undefined || longest.length < 3) { + throw new Error( + 'No sample is long enough to build an answerable needle (>= token_length 3). ' + + 'A freeTextSearch domain must carry at least one such sample in the catalog.', + ) + } + + const value = longest.toLowerCase() + const needles: Needle[] = [ + // Degenerate: exactly one trigram. Matches whether or not `include_original` + // is honoured, because the whole needle IS a trigram. + { label: 'a 3-character needle (one trigram)', needle: value.slice(0, 3) }, + // The whole stored value. Matches under either behaviour. + { label: 'the whole stored value', needle: value }, + // Absent from every sample, so it must never match. Guards against a + // predicate that ignores its operand — and against a bloom false positive + // being mistaken for coverage. + { label: 'a needle absent from every value', needle: 'qqqzzz' }, + ] + + // The discriminating case: a strict substring longer than one trigram, drawn + // from the interior. Fails the moment a whole-needle token enters the operand. + // Requires length >= 7: at 6 the interior slice `slice(2, 5)` is itself a + // single trigram, so the needle would be no more discriminating than the + // degenerate one above and the guard would be toothless. + if (value.length >= 7) { + needles.splice(1, 0, { + label: 'a strict interior substring longer than one trigram', + needle: value.slice(2, Math.min(value.length - 1, 8)), + }) + } + + return needles +} + +/** A representative operand for a rejected operation — the value never reaches the DB. */ +function sampleOpFor( + kind: QueryOp['kind'], + column: string, + value: Plain, +): QueryOp { + switch (kind) { + case 'in': + case 'notIn': + return { kind, column, values: [value] } + case 'between': + case 'notBetween': + return { kind, column, lo: value, hi: value } + case 'matches': + return { + kind, + column, + needle: + String(value).length >= 3 + ? String(value).slice(0, 3).toLowerCase() + : 'abc', + } + case 'order': + return { kind, column, direction: 'asc' } + case 'isNull': + case 'isNotNull': + return { kind, column } + default: + return { kind, column, value } + } +} + +export function runFamilySuite( + family: FamilyName, + makeAdapter: () => IntegrationAdapter, +): void { + const adapter = makeAdapter() + const domains = domainsForFamily(family) + + // A family whose every domain is deferred (e.g. `json`: containment queries + // don't fit the scalar oracle this driver runs). It carries no op-matrix + // coverage here — its real coverage lives in dedicated suites (`json-crypto`, + // `json-contains`). Emit one assertion documenting the deferral so the family + // stays visible and is not a silent skip, rather than letting `planTable` throw + // on an empty column set. A family with NO domains at all (covered or deferred) + // is a wiring bug and still falls through to that throw. + if (domains.length === 0) { + const deferred = deferredForFamily(family) + if (deferred.length > 0) { + describe(`v3 ${adapter.name} — ${family}`, () => { + it('is fully deferred from the op-matrix; covered by dedicated suites', () => { + for (const { reason } of deferred) expect(reason).not.toBe('') + }) + }) + return + } + } + + // Unique per run so a crashed run never leaves a table that shadows the next. + const runId = Math.random().toString(36).slice(2, 8) + const table = planTable(family, domains, runId) + const plan = planRows(domains, runId) + const { rowKeys, byKey } = plan + + describe(`v3 ${adapter.name} — ${family}`, () => { + beforeAll(async () => { + await adapter.setup() + await adapter.createTable(table) + + // Disjoint, interleaved halves: any predicate matching more than one row + // necessarily spans both encryption paths. + for (const key of plan.singleKeys) { + await adapter.insertSingle(table, byKey[key] as never) + } + await adapter.insertBulk( + table, + plan.bulkKeys.map((key) => byKey[key] as never), + ) + // Every encrypted column NULL. Goes through the single path; the bulk path + // is already proven by the value rows. + await adapter.insertSingle(table, plan.nullRow) + }, 300_000) + + afterAll(async () => { + await adapter.teardown() + }) + + for (const domain of domains) { + describe(domain.bare, () => { + const { slug, spec } = domain + const values = distinctValues(spec, rowKeys) + const min = values[0] as Plain + const max = values[values.length - 1] as Plain + + const positive = positiveOps(spec.capabilities, adapter.supportedOps) + const negative = negativeOps(spec.capabilities, adapter.supportedOps) + + const expectRows = async (op: QueryOp, expected: string[]) => { + const rows = await adapter.run(table, op) + expect([...rows].sort()).toEqual([...expected].sort()) + } + + const keysWhere = (predicate: (value: Plain) => boolean) => + expectedKeysFor(spec, rowKeys, predicate) + + if (positive.has('eq')) { + it.each(values)('eq(%s) selects exactly its rows', async (value) => { + await expectRows( + { kind: 'eq', column: slug, value }, + keysWhere((v) => comparePlain(v, value) === 0), + ) + }) + } + + if (positive.has('ne')) { + it('ne excludes exactly its rows', async () => { + await expectRows( + { kind: 'ne', column: slug, value: min }, + keysWhere((v) => comparePlain(v, min) !== 0), + ) + }) + } + + if (positive.has('in')) { + // Adapters with a second `in`-list code path drive both against the + // same oracle. See `IntegrationAdapter.hasRawInListPath`. + const variants = adapter.hasRawInListPath ? [false, true] : [false] + for (const asRawFilter of variants) { + const label = asRawFilter ? 'filter(in)' : 'in()' + + it(`${label} selects the union of the listed values`, async () => { + const listed = values.slice(0, 2) + await expectRows( + { kind: 'in', column: slug, values: listed, asRawFilter }, + keysWhere((v) => listed.some((l) => comparePlain(v, l) === 0)), + ) + }) + + it(`${label} excludes rows whose value is absent from the list`, async () => { + // Guards against a predicate that matches everything: without this, + // a filter that ignored its operand would pass the test above. + await expectRows( + { kind: 'in', column: slug, values: [min], asRawFilter }, + keysWhere((v) => comparePlain(v, min) === 0), + ) + }) + } + } + + if (positive.has('notIn')) { + it('notIn excludes the listed values', async () => { + await expectRows( + { kind: 'notIn', column: slug, values: [min] }, + keysWhere((v) => comparePlain(v, min) !== 0), + ) + }) + } + + for (const kind of ['gt', 'gte', 'lt', 'lte'] as const) { + if (!positive.has(kind)) continue + it.each([ + min, + max, + ])(`${kind}(%s) matches the oracle`, async (bound) => { + const cmp = { + gt: (c: number) => c > 0, + gte: (c: number) => c >= 0, + lt: (c: number) => c < 0, + lte: (c: number) => c <= 0, + }[kind] + await expectRows( + { kind, column: slug, value: bound }, + keysWhere((v) => cmp(comparePlain(v, bound))), + ) + }) + } + + if (positive.has('between')) { + it('between(min, max) spans every row', async () => { + await expectRows( + { kind: 'between', column: slug, lo: min, hi: max }, + [...rowKeys], + ) + }) + + it('between(v, v) selects only that value', async () => { + await expectRows( + { kind: 'between', column: slug, lo: min, hi: min }, + keysWhere((v) => comparePlain(v, min) === 0), + ) + }) + } + + if (positive.has('notBetween')) { + it('notBetween(min, max) selects nothing', async () => { + await expectRows( + { kind: 'notBetween', column: slug, lo: min, hi: max }, + [], + ) + }) + } + + if (positive.has('matches')) { + it.each(needlesFrom(values))('matches: $label', async ({ + needle, + }) => { + await expectRows( + { kind: 'matches', column: slug, needle }, + keysWhere((v) => matchesPlain(v, needle)), + ) + }) + } + + if (positive.has('order')) { + it.each([ + 'asc', + 'desc', + ] as const)('order(%s) returns rows in plaintext order', async (direction) => { + // Order is the one operation whose ROW ORDER is the assertion, so + // it does not go through `expectRows` (which sorts both sides). + const rows = await adapter.run(table, { + kind: 'order', + column: slug, + direction, + }) + expect(rows).toEqual(sortedKeysFor(spec, rowKeys, direction)) + }) + } + + // Structural, never capability-gated: a NULL plaintext is a SQL NULL on + // every domain, storage-only ones included. + it('isNull selects only the all-null row', async () => { + await expectRows({ kind: 'isNull', column: slug }, ['null']) + }) + + it('isNotNull selects every value row', async () => { + await expectRows({ kind: 'isNotNull', column: slug }, [...rowKeys]) + }) + + // Proves BOTH encryption paths produced queryable ciphertext. The eq + // loop above already spans them, but only implicitly; assert it. + it('both encrypt paths produced queryable ciphertext', async () => { + const rows = await adapter.run(table, { + kind: 'isNotNull', + column: slug, + }) + expect(rows).toEqual(expect.arrayContaining([...plan.singleKeys])) + expect(rows).toEqual(expect.arrayContaining([...plan.bulkKeys])) + }) + + for (const kind of negative) { + it(`rejects ${kind}: not supported by this domain's capabilities`, async () => { + await adapter.expectRejected(table, sampleOpFor(kind, slug, min)) + }) + } + + for (const kind of adapter.alwaysRejectedOps) { + if (negative.has(kind)) continue // already covered above + it(`rejects ${kind}: refused on every encrypted column by this adapter`, async () => { + await adapter.expectRejected(table, sampleOpFor(kind, slug, min)) + }) + } + }) + } + }) +} diff --git a/packages/test-kit/tsconfig.json b/packages/test-kit/tsconfig.json new file mode 100644 index 000000000..0730f54fb --- /dev/null +++ b/packages/test-kit/tsconfig.json @@ -0,0 +1,42 @@ +{ + "compilerOptions": { + "lib": ["ES2022"], + "target": "ES2022", + "module": "ESNext", + "moduleDetection": "force", + "esModuleInterop": true, + + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "verbatimModuleSyntax": true, + "noEmit": true, + + // Mirrors `packages/stack/tsconfig.json`: protect-ffi 0.24+ uses + // conditional exports, and bundler resolution omits `node` by default. + "customConditions": ["node"], + + "strict": true, + "skipLibCheck": true, + "noFallthroughCasesInSwitch": true, + "noUncheckedIndexedAccess": true, + + // Resolve stack to SOURCE, not `dist`. Without this the kit — and every + // unit suite that imports the catalog through it — would only typecheck + // after `pnpm build`, coupling `pnpm test` to a build step. The matching + // runtime aliases live in `vitest.shared.ts`. + "baseUrl": ".", + "paths": { + "@cipherstash/stack": ["../stack/src/index.ts"], + "@cipherstash/stack/eql/v3": ["../stack/src/eql/v3/index.ts"], + "@cipherstash/stack/schema": ["../stack/src/schema/index.ts"], + "@cipherstash/stack/v3": ["../stack/src/encryption/v3.ts"], + + // Resolving stack to source means we also inherit stack's OWN internal + // alias: `src/eql/v3/columns.ts` imports `@/schema`. Without this the + // kit's typecheck fails inside stack's sources rather than in the kit. + "@cipherstash/stack/adapter-kit": ["../stack/src/adapter-kit.ts"], + "@/*": ["../stack/src/*"] + } + }, + "include": ["src/**/*.ts"] +} diff --git a/packages/wizard/src/__tests__/interface.test.ts b/packages/wizard/src/__tests__/interface.test.ts index 33172a8b8..b81a25911 100644 --- a/packages/wizard/src/__tests__/interface.test.ts +++ b/packages/wizard/src/__tests__/interface.test.ts @@ -76,21 +76,22 @@ describe('wizardCanUseTool', () => { // The doctrine tells the agent to add placeholder keys to `.env.example`. // The guard covers Edit and Write as well as Read, so a blanket `.env.` // rule made the file the agent is told to write unreachable. - it.each(['.env.example', '.env.sample', '.env.template'])( - 'allows Read/Edit/Write/Glob on %s', - (name) => { - expect(wizardCanUseTool('Read', { file_path: `/project/${name}` })).toBe( - true, - ) - expect(wizardCanUseTool('Edit', { file_path: `/project/${name}` })).toBe( - true, - ) - expect( - wizardCanUseTool('Write', { file_path: `/project/${name}` }), - ).toBe(true) - expect(wizardCanUseTool('Glob', { pattern: name })).toBe(true) - }, - ) + it.each([ + '.env.example', + '.env.sample', + '.env.template', + ])('allows Read/Edit/Write/Glob on %s', (name) => { + expect(wizardCanUseTool('Read', { file_path: `/project/${name}` })).toBe( + true, + ) + expect(wizardCanUseTool('Edit', { file_path: `/project/${name}` })).toBe( + true, + ) + expect(wizardCanUseTool('Write', { file_path: `/project/${name}` })).toBe( + true, + ) + expect(wizardCanUseTool('Glob', { pattern: name })).toBe(true) + }) it('still blocks value-bearing files that only start with a template name', () => { expect( diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 481b54e59..ea152ac6b 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -110,7 +110,7 @@ importers: version: 7.8.5 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) yaml: specifier: ^2.9.0 version: 2.9.0 @@ -120,6 +120,12 @@ importers: '@cipherstash/stack': specifier: workspace:* version: link:../../packages/stack + '@cipherstash/stack-drizzle': + specifier: workspace:* + version: link:../../packages/stack-drizzle + '@cipherstash/stack-supabase': + specifier: workspace:* + version: link:../../packages/stack-supabase dotenv: specifier: ^17.4.2 version: 17.4.2 @@ -208,6 +214,9 @@ importers: '@cipherstash/stack': specifier: workspace:* version: link:../stack + '@cipherstash/stack-drizzle': + specifier: workspace:* + version: link:../stack-drizzle drizzle-orm: specifier: 0.45.2 version: 0.45.2(@types/pg@8.20.0)(gel@2.2.0)(mysql2@3.16.0)(pg@8.20.0)(postgres@3.4.9) @@ -261,6 +270,9 @@ importers: specifier: ^3.25.76 version: 3.25.76 devDependencies: + '@cipherstash/eql': + specifier: 3.0.0 + version: 3.0.0 '@cipherstash/stack': specifier: workspace:* version: link:../stack @@ -284,7 +296,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) optionalDependencies: '@cipherstash/auth-darwin-arm64': specifier: catalog:repo @@ -343,7 +355,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) packages/migrate: dependencies: @@ -371,7 +383,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) packages/nextjs: dependencies: @@ -396,7 +408,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) optionalDependencies: '@rollup/rollup-linux-x64-gnu': specifier: 4.60.4 @@ -479,7 +491,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) packages/protect: dependencies: @@ -525,7 +537,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) optionalDependencies: '@rollup/rollup-linux-x64-gnu': specifier: 4.60.4 @@ -554,7 +566,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) packages/schema: dependencies: @@ -570,7 +582,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) packages/stack: dependencies: @@ -581,8 +593,8 @@ importers: specifier: catalog:repo version: 0.41.0(@cipherstash/auth-darwin-arm64@0.41.0)(@cipherstash/auth-darwin-x64@0.41.0)(@cipherstash/auth-linux-arm64-gnu@0.41.0)(@cipherstash/auth-linux-x64-gnu@0.41.0)(@cipherstash/auth-linux-x64-musl@0.41.0)(@cipherstash/auth-win32-x64-msvc@0.41.0) '@cipherstash/protect-ffi': - specifier: 0.28.0 - version: 0.28.0 + specifier: 0.29.0 + version: 0.29.0 evlog: specifier: 1.11.0 version: 1.11.0(next@15.5.18(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(react@19.2.3) @@ -593,12 +605,24 @@ importers: specifier: 3.25.76 version: 3.25.76 devDependencies: + '@cipherstash/eql': + specifier: 3.0.0 + version: 3.0.0 '@clack/prompts': specifier: ^1.4.0 version: 1.4.0 + '@clerk/backend': + specifier: 3.4.9 + version: 3.4.9(react-dom@19.2.3(react@19.2.3))(react@19.2.3) + '@supabase/postgrest-js': + specifier: 2.105.4 + version: 2.105.4 '@supabase/supabase-js': specifier: ^2.110.0 version: 2.110.0 + '@types/pg': + specifier: ^8.20.0 + version: 8.20.0 '@types/uuid': specifier: ^11.0.0 version: 11.0.0 @@ -607,16 +631,22 @@ importers: version: 17.4.2 drizzle-orm: specifier: ^0.45.2 - version: 0.45.2(@types/pg@8.20.0)(gel@2.2.0)(mysql2@3.16.0)(pg@8.21.0)(postgres@3.4.9) + version: 0.45.2(@types/pg@8.20.0)(gel@2.2.0)(mysql2@3.16.0)(pg@8.20.0)(postgres@3.4.9) execa: specifier: ^9.5.2 version: 9.6.1 + fast-check: + specifier: ^4.8.0 + version: 4.8.0 fta-cli: specifier: 3.0.0 version: 3.0.0 json-schema-to-typescript: specifier: ^15.0.2 version: 15.0.4 + pg: + specifier: 8.20.0 + version: 8.20.0 postgres: specifier: ^3.4.8 version: 3.4.9 @@ -631,7 +661,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) optionalDependencies: '@cipherstash/auth-darwin-arm64': specifier: catalog:repo @@ -652,6 +682,105 @@ importers: specifier: catalog:repo version: 0.41.0 + packages/stack-drizzle: + dependencies: + '@byteslice/result': + specifier: 0.2.0 + version: 0.2.0 + '@cipherstash/stack': + specifier: workspace:* + version: link:../stack + devDependencies: + '@cipherstash/protect-ffi': + specifier: 0.29.0 + version: 0.29.0 + '@cipherstash/test-kit': + specifier: workspace:* + version: link:../test-kit + dotenv: + specifier: 17.4.2 + version: 17.4.2 + drizzle-orm: + specifier: ^0.45.2 + version: 0.45.2(@types/pg@8.20.0)(gel@2.2.0)(mysql2@3.16.0)(pg@8.21.0)(postgres@3.4.9) + fta-cli: + specifier: 3.0.0 + version: 3.0.0 + postgres: + specifier: ^3.4.8 + version: 3.4.9 + tsup: + specifier: catalog:repo + version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.22.1)(typescript@5.9.3)(yaml@2.9.0) + typescript: + specifier: catalog:repo + version: 5.9.3 + vitest: + specifier: catalog:repo + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + + packages/stack-supabase: + dependencies: + '@cipherstash/stack': + specifier: workspace:* + version: link:../stack + devDependencies: + '@cipherstash/protect-ffi': + specifier: 0.29.0 + version: 0.29.0 + '@cipherstash/test-kit': + specifier: workspace:* + version: link:../test-kit + '@supabase/postgrest-js': + specifier: 2.105.4 + version: 2.105.4 + '@supabase/supabase-js': + specifier: ^2.110.0 + version: 2.110.0 + '@types/pg': + specifier: ^8.20.0 + version: 8.20.0 + dotenv: + specifier: 17.4.2 + version: 17.4.2 + fast-check: + specifier: ^4.8.0 + version: 4.8.0 + fta-cli: + specifier: 3.0.0 + version: 3.0.0 + pg: + specifier: 8.20.0 + version: 8.20.0 + postgres: + specifier: ^3.4.8 + version: 3.4.9 + tsup: + specifier: catalog:repo + version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.22.1)(typescript@5.9.3)(yaml@2.9.0) + typescript: + specifier: catalog:repo + version: 5.9.3 + vitest: + specifier: catalog:repo + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + + packages/test-kit: + dependencies: + '@cipherstash/stack': + specifier: workspace:* + version: link:../stack + devDependencies: + '@clerk/backend': + specifier: 3.4.9 + version: 3.4.9(react-dom@19.2.3(react@19.2.3))(react@19.2.3) + typescript: + specifier: catalog:repo + version: 5.9.3 + vitest: + specifier: catalog:repo + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + packages/wizard: dependencies: '@anthropic-ai/claude-agent-sdk': @@ -696,7 +825,7 @@ importers: version: 5.9.3 vitest: specifier: catalog:repo - version: 3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + version: 3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) optionalDependencies: '@cipherstash/auth-darwin-arm64': specifier: catalog:repo @@ -972,13 +1101,16 @@ packages: '@cipherstash/auth-win32-x64-msvc': optional: true + '@cipherstash/eql@3.0.0': + resolution: {integrity: sha512-hi8zrIx3FEokLhgJaUN4VsRagUnxhyJOn6gbvIxjBpZjEXJdMQQXkkSq4eV6Bz2sroUf1+d+qeX2H2zejcM1Dg==} + '@cipherstash/protect-ffi-darwin-arm64@0.23.0': resolution: {integrity: sha512-DhkKC+trOfk3RLDvPXqGsrpWdVnLAMEVLUI59OuR9tdTcJeiABtbQx8VaXdbzvNxnbkoDnOqbFRE5D11Z7nerQ==} cpu: [arm64] os: [darwin] - '@cipherstash/protect-ffi-darwin-arm64@0.28.0': - resolution: {integrity: sha512-QRwiovEdgjstbaCONZGYXA82NG4Gwz9mJOZeAzthUmNIQfnVErO9UQAfJ+I1T/YG1Ww2FCWcHltXMl/qjyeK4A==} + '@cipherstash/protect-ffi-darwin-arm64@0.29.0': + resolution: {integrity: sha512-Licuimkh6Y2cCAUQSBcwSzmjT9NOvA2ShC2wqaacA6fyWXtPlvRHvh5hct5fP0jBoKgMLAIu1qVJG0DdPU2OGQ==} cpu: [arm64] os: [darwin] @@ -987,8 +1119,8 @@ packages: cpu: [x64] os: [darwin] - '@cipherstash/protect-ffi-darwin-x64@0.28.0': - resolution: {integrity: sha512-H8qB2z3drJSc2bR5ITsJSFrOoNKvORbauTdHmaS1e5OleXsLl/F+56Zvghz8NWs+bXs/2aVzHxpYte8FgV8AAQ==} + '@cipherstash/protect-ffi-darwin-x64@0.29.0': + resolution: {integrity: sha512-rRVrhcwrmrPr4xw6RGuBht9SwhfdumSan9P+BV8t9ivmnmpR/GA7+3425794R07jSdwpjkyob0kkuLHwI+Wc1A==} cpu: [x64] os: [darwin] @@ -997,8 +1129,8 @@ packages: cpu: [arm64] os: [linux] - '@cipherstash/protect-ffi-linux-arm64-gnu@0.28.0': - resolution: {integrity: sha512-h7vZxB/wako6j1jspkGl41gptTN1dBTWYqAR6jhVnvKJK0TBlyUKuSJwO1NeqyNfFQ/b1KmqJ11JGvY95uRZOA==} + '@cipherstash/protect-ffi-linux-arm64-gnu@0.29.0': + resolution: {integrity: sha512-zWb9gHJQo9iJw8AD0nkUORB4AxrWN66fePt/rxs9hCp/gBNMe19dJMqAUs8pgG7+S2mIi8SPa/TPm86wraTDCA==} cpu: [arm64] os: [linux] @@ -1007,8 +1139,8 @@ packages: cpu: [x64] os: [linux] - '@cipherstash/protect-ffi-linux-x64-gnu@0.28.0': - resolution: {integrity: sha512-PgHn0Og0PiCwFdV4yKhipGKfqkCXP6Xchyy6ykTaISabmSlkkbRNkyNF1/tZEQYF65sm5gmqSpwSYzKODaAsbg==} + '@cipherstash/protect-ffi-linux-x64-gnu@0.29.0': + resolution: {integrity: sha512-f+yz03a6ZKcunzf3UyBEDhBla9ux535pqkj+MJirlhI4x0cVevmwI4SYO+CaNAqAdIhfi/EDqsN3FcXTltoktA==} cpu: [x64] os: [linux] @@ -1017,8 +1149,8 @@ packages: cpu: [x64] os: [linux] - '@cipherstash/protect-ffi-linux-x64-musl@0.28.0': - resolution: {integrity: sha512-fMu3k1Y3wYMcGbGpVtrlCMNRLd1//5c9ZHcyWFjKFqimOCbBO5akgCQij4zcvj4kYDHtveu9dOdOKVhaG8k6hQ==} + '@cipherstash/protect-ffi-linux-x64-musl@0.29.0': + resolution: {integrity: sha512-bZUji9Za65dUoVP2b1FUBddjftZkkRDSJkAknZZVK6QEZ5SbOLyQwOYS1wT1/6zt1k6cpF6oT2+CzwZDEcggVw==} cpu: [x64] os: [linux] @@ -1027,16 +1159,16 @@ packages: cpu: [x64] os: [win32] - '@cipherstash/protect-ffi-win32-x64-msvc@0.28.0': - resolution: {integrity: sha512-tF0y7TcyBtgN/jHodYMnrJ4etLkEI/klzDivW8Q8eIuIdoJ3q5muZKFIhNX0MbDDdh2O4GsRdNhXRubs7BiFpA==} + '@cipherstash/protect-ffi-win32-x64-msvc@0.29.0': + resolution: {integrity: sha512-OZ39ODuq07+RTALQwJsWu+EFZYdaQeK/u9IFhpkr/Bf9hY/f7SvnTk6FrZEjUeTsR3mYqfZ3jp3VREXUncqTGA==} cpu: [x64] os: [win32] '@cipherstash/protect-ffi@0.23.0': resolution: {integrity: sha512-Ca8MKLrrumC561VoPDOhuUZcF8C8YenqO1Ig9hSJSRUB+jFeIJXeyn7glExsvKYWtxOx/pRub9FV8A0RyuPHMg==} - '@cipherstash/protect-ffi@0.28.0': - resolution: {integrity: sha512-R2L/8HwMREkVKlR5KCcuELIWz4QNButSBQzY+nRDHl1PUXjRqWG1h265FkKVtTXKNKUup7rB4mswu+M+t9KF3A==} + '@cipherstash/protect-ffi@0.29.0': + resolution: {integrity: sha512-sBnmODaUUAClDWOlCZPf91cIscxZq9+lVjIj9TqnPTvMc7TIjIpWuKYFyJIx8Ur1EAKy8KZ00Eoy9viSsW/GLQ==} '@clack/core@1.3.1': resolution: {integrity: sha512-fT1qHVGAag4IEkrupZ6lRRbNCs1vS9P01KB/sG8zKgvUztbYtFBtQpjSITNwooDZ83tpsPzP0mRNs1/KVszCRA==} @@ -2093,277 +2225,139 @@ packages: typescript: optional: true - '@rollup/rollup-android-arm-eabi@4.59.0': - resolution: {integrity: sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==} - cpu: [arm] - os: [android] - '@rollup/rollup-android-arm-eabi@4.60.4': resolution: {integrity: sha512-F5QXMSiFebS9hKZj02XhWLLnRpJ3B3AROP0tWbFBSj+6kCbg5m9j5JoHKd4mmSVy5mS/IMQloYgYxCuJC0fxEQ==} cpu: [arm] os: [android] - '@rollup/rollup-android-arm64@4.59.0': - resolution: {integrity: sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==} - cpu: [arm64] - os: [android] - '@rollup/rollup-android-arm64@4.60.4': resolution: {integrity: sha512-GxxTKApUpzRhof7poWvCJHRF51C67u1R7D6DiluBE8wKU1u5GWE8t+v81JvJYtbawoBFX1hLv5Ei4eVjkWokaw==} cpu: [arm64] os: [android] - '@rollup/rollup-darwin-arm64@4.59.0': - resolution: {integrity: sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==} - cpu: [arm64] - os: [darwin] - '@rollup/rollup-darwin-arm64@4.60.4': resolution: {integrity: sha512-tua0TaJxMOB1R0V0RS1jFZ/RpURFDJIOR2A6jWwQeawuFyS4gBW+rntLRaQd0EQ4bd6Vp44Z2rXW+YYDBsj6IA==} cpu: [arm64] os: [darwin] - '@rollup/rollup-darwin-x64@4.59.0': - resolution: {integrity: sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==} - cpu: [x64] - os: [darwin] - '@rollup/rollup-darwin-x64@4.60.4': resolution: {integrity: sha512-CSKq7MsP+5PFIcydhAiR1K0UhEI1A2jWXVKHPCBZ151yOutENwvnPocgVHkivu2kviURtCEB6zUQw0vs8RrhMg==} cpu: [x64] os: [darwin] - '@rollup/rollup-freebsd-arm64@4.59.0': - resolution: {integrity: sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==} - cpu: [arm64] - os: [freebsd] - '@rollup/rollup-freebsd-arm64@4.60.4': resolution: {integrity: sha512-+O8OkVdyvXMtJEciu2wS/pzm1IxntEEQx3z5TAVy4l32G0etZn+RsA48ARRrFm6Ri8fvqPQfgrvNxSjKAbnd3g==} cpu: [arm64] os: [freebsd] - '@rollup/rollup-freebsd-x64@4.59.0': - resolution: {integrity: sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==} - cpu: [x64] - os: [freebsd] - '@rollup/rollup-freebsd-x64@4.60.4': resolution: {integrity: sha512-Iw3oMskH3AfNuhU0MSN7vNbdi4me/NiYo2azqPz/Le16zHSa+3RRmliCMWWQmh4lcndccU40xcJuTYJZxNo/lw==} cpu: [x64] os: [freebsd] - '@rollup/rollup-linux-arm-gnueabihf@4.59.0': - resolution: {integrity: sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==} - cpu: [arm] - os: [linux] - libc: [glibc] - '@rollup/rollup-linux-arm-gnueabihf@4.60.4': resolution: {integrity: sha512-EIPRXTVQpHyF8WOo219AD2yEltPehLTcTMz2fn6JsatLYSzQf00hj3rulF+yauOlF9/FtM2WpkT/hJh/KJFGhA==} cpu: [arm] os: [linux] libc: [glibc] - '@rollup/rollup-linux-arm-musleabihf@4.59.0': - resolution: {integrity: sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==} - cpu: [arm] - os: [linux] - libc: [musl] - '@rollup/rollup-linux-arm-musleabihf@4.60.4': resolution: {integrity: sha512-J3Yh9PzzF1Ovah2At+lHiGQdsYgArxBbXv/zHfSyaiFQEqvNv7DcW98pCrmdjCZBrqBiKrKKe2V+aaSGWuBe/w==} cpu: [arm] os: [linux] libc: [musl] - '@rollup/rollup-linux-arm64-gnu@4.59.0': - resolution: {integrity: sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==} - cpu: [arm64] - os: [linux] - libc: [glibc] - '@rollup/rollup-linux-arm64-gnu@4.60.4': resolution: {integrity: sha512-BFDEZMYfUvLn37ONE1yMBojPxnMlTFsdyNoqncT0qFq1mAfllL+ATMMJd8TeuVMiX84s1KbcxcZbXInmcO2mRg==} cpu: [arm64] os: [linux] libc: [glibc] - '@rollup/rollup-linux-arm64-musl@4.59.0': - resolution: {integrity: sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==} - cpu: [arm64] - os: [linux] - libc: [musl] - '@rollup/rollup-linux-arm64-musl@4.60.4': resolution: {integrity: sha512-pc9EYOSlOgdQ2uPl1o9PF6/kLSgaUosia7gOuS8mB69IxJvlclko1MECXysjs5ryez1/5zjYqx3+xYU0TU6R1A==} cpu: [arm64] os: [linux] libc: [musl] - '@rollup/rollup-linux-loong64-gnu@4.59.0': - resolution: {integrity: sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==} - cpu: [loong64] - os: [linux] - libc: [glibc] - '@rollup/rollup-linux-loong64-gnu@4.60.4': resolution: {integrity: sha512-NxnomyxYerDh5n4iLrNa+sH+Z+U4BMEE46V2PgQ/hoB909i8gV1M5wPojWg9fk1jWpO3IQnOs20K4wyZuFLEFQ==} cpu: [loong64] os: [linux] libc: [glibc] - '@rollup/rollup-linux-loong64-musl@4.59.0': - resolution: {integrity: sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==} - cpu: [loong64] - os: [linux] - libc: [musl] - '@rollup/rollup-linux-loong64-musl@4.60.4': resolution: {integrity: sha512-nbJnQ8a3z1mtmrwImCYhc6BGpThAyYVRQxw9uKSKG4wR6aAYno9sVjJ0zaZcW9BPJX1GbrDPf+SvdWjgTuDmnw==} cpu: [loong64] os: [linux] libc: [musl] - '@rollup/rollup-linux-ppc64-gnu@4.59.0': - resolution: {integrity: sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==} - cpu: [ppc64] - os: [linux] - libc: [glibc] - '@rollup/rollup-linux-ppc64-gnu@4.60.4': resolution: {integrity: sha512-2EU6acNrQLd8tYvo/LXW535wupT3m6fo7HKo6lr7ktQoItxTyOL1ZCR/GfGCuXl2vR+zmfI6eRXkSemafv+iVg==} cpu: [ppc64] os: [linux] libc: [glibc] - '@rollup/rollup-linux-ppc64-musl@4.59.0': - resolution: {integrity: sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==} - cpu: [ppc64] - os: [linux] - libc: [musl] - '@rollup/rollup-linux-ppc64-musl@4.60.4': resolution: {integrity: sha512-WeBtoMuaMxiiIrO2IYP3xs6GMWkJP2C0EoT8beTLkUPmzV1i/UcOSVw1d5r9KBODtHKilG5yFxsGRnBbK3wJ4A==} cpu: [ppc64] os: [linux] libc: [musl] - '@rollup/rollup-linux-riscv64-gnu@4.59.0': - resolution: {integrity: sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==} - cpu: [riscv64] - os: [linux] - libc: [glibc] - '@rollup/rollup-linux-riscv64-gnu@4.60.4': resolution: {integrity: sha512-FJHFfqpKUI3A10WrWKiFbBZ7yVbGT4q4B5o1qKFFojqpaYoh9LrQgqWCmmcxQzVSXYtyB5bzkXrYzlHTs21MYA==} cpu: [riscv64] os: [linux] libc: [glibc] - '@rollup/rollup-linux-riscv64-musl@4.59.0': - resolution: {integrity: sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==} - cpu: [riscv64] - os: [linux] - libc: [musl] - '@rollup/rollup-linux-riscv64-musl@4.60.4': resolution: {integrity: sha512-mcEl6CUT5IAUmQf1m9FYSmVqCJlpQ8r8eyftFUHG8i9OhY7BkBXSUdnLH5DOf0wCOjcP9v/QO93zpmF1SptCCw==} cpu: [riscv64] os: [linux] libc: [musl] - '@rollup/rollup-linux-s390x-gnu@4.59.0': - resolution: {integrity: sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==} - cpu: [s390x] - os: [linux] - libc: [glibc] - '@rollup/rollup-linux-s390x-gnu@4.60.4': resolution: {integrity: sha512-ynt3JxVd2w2buzoKDWIyiV1pJW93xlQic1THVLXilz429oijRpSHivZAgp65KBu+cMcgf1eVVjdnTLvPxgCuoQ==} cpu: [s390x] os: [linux] libc: [glibc] - '@rollup/rollup-linux-x64-gnu@4.59.0': - resolution: {integrity: sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==} - cpu: [x64] - os: [linux] - libc: [glibc] - '@rollup/rollup-linux-x64-gnu@4.60.4': resolution: {integrity: sha512-Boiz5+MsaROEWDf+GGEwF8VMHGhlUoQMtIPjOgA5fv4osupqTVnJteQNKJwUcnUog2G55jYXH7KZFFiJe0TEzQ==} cpu: [x64] os: [linux] libc: [glibc] - '@rollup/rollup-linux-x64-musl@4.59.0': - resolution: {integrity: sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==} - cpu: [x64] - os: [linux] - libc: [musl] - '@rollup/rollup-linux-x64-musl@4.60.4': resolution: {integrity: sha512-+qfSY27qIrFfI/Hom04KYFw3GKZSGU4lXus51wsb5EuySfFlWRwjkKWoE9emgRw/ukoT4Udsj4W/+xxG8VbPKg==} cpu: [x64] os: [linux] libc: [musl] - '@rollup/rollup-openbsd-x64@4.59.0': - resolution: {integrity: sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==} - cpu: [x64] - os: [openbsd] - '@rollup/rollup-openbsd-x64@4.60.4': resolution: {integrity: sha512-VpTfOPHgVXEBeeR8hZ2O0F3aSso+JDWqTWmTmzcQKted54IAdUVbxE+j/MVxUsKa8L20HJhv3vUezVPoquqWjA==} cpu: [x64] os: [openbsd] - '@rollup/rollup-openharmony-arm64@4.59.0': - resolution: {integrity: sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==} - cpu: [arm64] - os: [openharmony] - '@rollup/rollup-openharmony-arm64@4.60.4': resolution: {integrity: sha512-IPOsh5aRYuLv/nkU51X10Bf75Bsf6+gZdx1X+QP5QM6lIJFHHqbHLG0uJn/hWthzo13UAc2umiUorqZy3axoZg==} cpu: [arm64] os: [openharmony] - '@rollup/rollup-win32-arm64-msvc@4.59.0': - resolution: {integrity: sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==} - cpu: [arm64] - os: [win32] - '@rollup/rollup-win32-arm64-msvc@4.60.4': resolution: {integrity: sha512-4QzE9E81OohJ/HKzHhsqU+zcYYojVOXlFMs1DdyMT6qXl/niOH7AVElmmEdUNHHS/oRkc++d5k6Vy85zFs0DEw==} cpu: [arm64] os: [win32] - '@rollup/rollup-win32-ia32-msvc@4.59.0': - resolution: {integrity: sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==} - cpu: [ia32] - os: [win32] - '@rollup/rollup-win32-ia32-msvc@4.60.4': resolution: {integrity: sha512-zTPgT1YuHHcd+Tmx7h8aml0FWFVelV5N54oHow9SLj+GfoDy/huQ+UV396N/C7KpMDMiPspRktzM1/0r1usYEA==} cpu: [ia32] os: [win32] - '@rollup/rollup-win32-x64-gnu@4.59.0': - resolution: {integrity: sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==} - cpu: [x64] - os: [win32] - '@rollup/rollup-win32-x64-gnu@4.60.4': resolution: {integrity: sha512-DRS4G7mi9lJxqEDezIkKCaUIKCrLUUDCUaCsTPCi/rtqaC6D/jjwslMQyiDU50Ka0JKpeXeRBFBAXwArY52vBw==} cpu: [x64] os: [win32] - '@rollup/rollup-win32-x64-msvc@4.59.0': - resolution: {integrity: sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==} - cpu: [x64] - os: [win32] - '@rollup/rollup-win32-x64-msvc@4.60.4': resolution: {integrity: sha512-QVTUovf40zgTqlFVrKA1uXMVvU2QWEFWfAH8Wdc48IxLvrJMQVMBRjuQyUpzZCDkakImib9eVazbWlC6ksWtJw==} cpu: [x64] @@ -2396,6 +2390,10 @@ packages: '@supabase/phoenix@0.4.4': resolution: {integrity: sha512-Gt0pqoXuIqX/8dvG0OKp/wMCobXNH3klNbUPBNyOfN0YA1IswrM3HyWFMOPk1Jy+BRaIyDPcFx4jLBwHNmlyfQ==} + '@supabase/postgrest-js@2.105.4': + resolution: {integrity: sha512-SppIyLo/kTwIlz1qpv2HN1EQqBg0GVktrDDFsXygYROha3MgVn4rT7p5EjFHFqXQm2rdRGb/BI7bc+jr10m91w==} + engines: {node: '>=20.0.0'} + '@supabase/postgrest-js@2.110.0': resolution: {integrity: sha512-ZbC1QZL3jcvBUfVKjJbgRM27G4Mg3Zzqdm44m5pJafe1e52Cli793EOnwQucomBAGEUDd03Nzaf7XV3ji/XexQ==} engines: {node: '>=22.0.0'} @@ -2469,8 +2467,8 @@ packages: '@types/node@22.20.0': resolution: {integrity: sha512-QWlFW2wf3nTjC13/DqRnBpR4ZO36VJH/JVBkA/vcnmbTBNQIlnObqyqZE1tUR7+Ni23Lda8R1BxMfbXRpCUx5g==} - '@types/node@26.1.0': - resolution: {integrity: sha512-O0A1G3xPGy4w7AgQdAQYUlQ+BKk2Oovw8eRpofyp5KdBZULnbe+WqaOVNrm705SHphCiG4XHsACrSmPu1f+Kgw==} + '@types/node@25.8.0': + resolution: {integrity: sha512-TCFSk8IZh+iLX1xtksoBVtdmgL+1IX0fC9BeU4QqFSuNdN/K+HUlhqOzEmSYYpZUVsLYcPqc9KX+60iDuninSQ==} '@types/pg@8.16.0': resolution: {integrity: sha512-RmhMd/wD+CF8Dfo+cVIy3RR5cl8CyfXQ0tGgW6XBL8L4LM/UTEbNXYRbLwU6w+CgrKBNbrQWt4FUtTfaU5jSYQ==} @@ -2518,11 +2516,6 @@ packages: resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==} engines: {node: '>= 0.6'} - acorn@8.16.0: - resolution: {integrity: sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==} - engines: {node: '>=0.4.0'} - hasBin: true - acorn@8.17.0: resolution: {integrity: sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==} engines: {node: '>=0.4.0'} @@ -3812,11 +3805,6 @@ packages: engines: {node: 20 || >=22} hasBin: true - rollup@4.59.0: - resolution: {integrity: sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==} - engines: {node: '>=18.0.0', npm: '>=8.0.0'} - hasBin: true - rollup@4.60.4: resolution: {integrity: sha512-WHeFSbZYsPu3+bLoNRUuAO+wavNlocOPf3wSHTP7hcFKVnJeWsYlCDbr3mTS14FCizf9ccIxXA8sGL8zKeQN3g==} engines: {node: '>=18.0.0', npm: '>=8.0.0'} @@ -4098,8 +4086,8 @@ packages: undici-types@6.21.0: resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==} - undici-types@8.3.0: - resolution: {integrity: sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==} + undici-types@7.24.6: + resolution: {integrity: sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==} unicorn-magic@0.3.0: resolution: {integrity: sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==} @@ -4516,40 +4504,42 @@ snapshots: '@cipherstash/auth-linux-x64-musl': 0.41.0 '@cipherstash/auth-win32-x64-msvc': 0.41.0 + '@cipherstash/eql@3.0.0': {} + '@cipherstash/protect-ffi-darwin-arm64@0.23.0': optional: true - '@cipherstash/protect-ffi-darwin-arm64@0.28.0': + '@cipherstash/protect-ffi-darwin-arm64@0.29.0': optional: true '@cipherstash/protect-ffi-darwin-x64@0.23.0': optional: true - '@cipherstash/protect-ffi-darwin-x64@0.28.0': + '@cipherstash/protect-ffi-darwin-x64@0.29.0': optional: true '@cipherstash/protect-ffi-linux-arm64-gnu@0.23.0': optional: true - '@cipherstash/protect-ffi-linux-arm64-gnu@0.28.0': + '@cipherstash/protect-ffi-linux-arm64-gnu@0.29.0': optional: true '@cipherstash/protect-ffi-linux-x64-gnu@0.23.0': optional: true - '@cipherstash/protect-ffi-linux-x64-gnu@0.28.0': + '@cipherstash/protect-ffi-linux-x64-gnu@0.29.0': optional: true '@cipherstash/protect-ffi-linux-x64-musl@0.23.0': optional: true - '@cipherstash/protect-ffi-linux-x64-musl@0.28.0': + '@cipherstash/protect-ffi-linux-x64-musl@0.29.0': optional: true '@cipherstash/protect-ffi-win32-x64-msvc@0.23.0': optional: true - '@cipherstash/protect-ffi-win32-x64-msvc@0.28.0': + '@cipherstash/protect-ffi-win32-x64-msvc@0.29.0': optional: true '@cipherstash/protect-ffi@0.23.0': @@ -4563,16 +4553,16 @@ snapshots: '@cipherstash/protect-ffi-linux-x64-musl': 0.23.0 '@cipherstash/protect-ffi-win32-x64-msvc': 0.23.0 - '@cipherstash/protect-ffi@0.28.0': + '@cipherstash/protect-ffi@0.29.0': dependencies: '@neon-rs/load': 0.1.82 optionalDependencies: - '@cipherstash/protect-ffi-darwin-arm64': 0.28.0 - '@cipherstash/protect-ffi-darwin-x64': 0.28.0 - '@cipherstash/protect-ffi-linux-arm64-gnu': 0.28.0 - '@cipherstash/protect-ffi-linux-x64-gnu': 0.28.0 - '@cipherstash/protect-ffi-linux-x64-musl': 0.28.0 - '@cipherstash/protect-ffi-win32-x64-msvc': 0.28.0 + '@cipherstash/protect-ffi-darwin-arm64': 0.29.0 + '@cipherstash/protect-ffi-darwin-x64': 0.29.0 + '@cipherstash/protect-ffi-linux-arm64-gnu': 0.29.0 + '@cipherstash/protect-ffi-linux-x64-gnu': 0.29.0 + '@cipherstash/protect-ffi-linux-x64-musl': 0.29.0 + '@cipherstash/protect-ffi-win32-x64-msvc': 0.29.0 '@clack/core@1.3.1': dependencies: @@ -5448,153 +5438,78 @@ snapshots: optionalDependencies: typescript: 5.9.3 - '@rollup/rollup-android-arm-eabi@4.59.0': - optional: true - '@rollup/rollup-android-arm-eabi@4.60.4': optional: true - '@rollup/rollup-android-arm64@4.59.0': - optional: true - '@rollup/rollup-android-arm64@4.60.4': optional: true - '@rollup/rollup-darwin-arm64@4.59.0': - optional: true - '@rollup/rollup-darwin-arm64@4.60.4': optional: true - '@rollup/rollup-darwin-x64@4.59.0': - optional: true - '@rollup/rollup-darwin-x64@4.60.4': optional: true - '@rollup/rollup-freebsd-arm64@4.59.0': - optional: true - '@rollup/rollup-freebsd-arm64@4.60.4': optional: true - '@rollup/rollup-freebsd-x64@4.59.0': - optional: true - '@rollup/rollup-freebsd-x64@4.60.4': optional: true - '@rollup/rollup-linux-arm-gnueabihf@4.59.0': - optional: true - '@rollup/rollup-linux-arm-gnueabihf@4.60.4': optional: true - '@rollup/rollup-linux-arm-musleabihf@4.59.0': - optional: true - '@rollup/rollup-linux-arm-musleabihf@4.60.4': optional: true - '@rollup/rollup-linux-arm64-gnu@4.59.0': - optional: true - '@rollup/rollup-linux-arm64-gnu@4.60.4': optional: true - '@rollup/rollup-linux-arm64-musl@4.59.0': - optional: true - '@rollup/rollup-linux-arm64-musl@4.60.4': optional: true - '@rollup/rollup-linux-loong64-gnu@4.59.0': - optional: true - '@rollup/rollup-linux-loong64-gnu@4.60.4': optional: true - '@rollup/rollup-linux-loong64-musl@4.59.0': - optional: true - '@rollup/rollup-linux-loong64-musl@4.60.4': optional: true - '@rollup/rollup-linux-ppc64-gnu@4.59.0': - optional: true - '@rollup/rollup-linux-ppc64-gnu@4.60.4': optional: true - '@rollup/rollup-linux-ppc64-musl@4.59.0': - optional: true - '@rollup/rollup-linux-ppc64-musl@4.60.4': optional: true - '@rollup/rollup-linux-riscv64-gnu@4.59.0': - optional: true - '@rollup/rollup-linux-riscv64-gnu@4.60.4': optional: true - '@rollup/rollup-linux-riscv64-musl@4.59.0': - optional: true - '@rollup/rollup-linux-riscv64-musl@4.60.4': optional: true - '@rollup/rollup-linux-s390x-gnu@4.59.0': - optional: true - '@rollup/rollup-linux-s390x-gnu@4.60.4': optional: true - '@rollup/rollup-linux-x64-gnu@4.59.0': - optional: true - '@rollup/rollup-linux-x64-gnu@4.60.4': optional: true - '@rollup/rollup-linux-x64-musl@4.59.0': - optional: true - '@rollup/rollup-linux-x64-musl@4.60.4': optional: true - '@rollup/rollup-openbsd-x64@4.59.0': - optional: true - '@rollup/rollup-openbsd-x64@4.60.4': optional: true - '@rollup/rollup-openharmony-arm64@4.59.0': - optional: true - '@rollup/rollup-openharmony-arm64@4.60.4': optional: true - '@rollup/rollup-win32-arm64-msvc@4.59.0': - optional: true - '@rollup/rollup-win32-arm64-msvc@4.60.4': optional: true - '@rollup/rollup-win32-ia32-msvc@4.59.0': - optional: true - '@rollup/rollup-win32-ia32-msvc@4.60.4': optional: true - '@rollup/rollup-win32-x64-gnu@4.59.0': - optional: true - '@rollup/rollup-win32-x64-gnu@4.60.4': optional: true - '@rollup/rollup-win32-x64-msvc@4.59.0': - optional: true - '@rollup/rollup-win32-x64-msvc@4.60.4': optional: true @@ -5618,6 +5533,10 @@ snapshots: '@supabase/phoenix@0.4.4': {} + '@supabase/postgrest-js@2.105.4': + dependencies: + tslib: 2.8.1 + '@supabase/postgrest-js@2.110.0': dependencies: tslib: 2.8.1 @@ -5683,9 +5602,9 @@ snapshots: dependencies: undici-types: 6.21.0 - '@types/node@26.1.0': + '@types/node@25.8.0': dependencies: - undici-types: 8.3.0 + undici-types: 7.24.6 optional: true '@types/pg@8.16.0': @@ -5697,7 +5616,7 @@ snapshots: '@types/pg@8.20.0': dependencies: '@types/node': 22.20.0 - pg-protocol: 1.13.0 + pg-protocol: 1.15.0 pg-types: 2.2.0 '@types/semver@7.7.1': {} @@ -5722,13 +5641,13 @@ snapshots: optionalDependencies: vite: 7.3.6(@types/node@22.20.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) - '@vitest/mocker@3.2.6(vite@7.3.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0))': + '@vitest/mocker@3.2.6(vite@7.3.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0))': dependencies: '@vitest/spy': 3.2.6 estree-walker: 3.0.3 magic-string: 0.30.21 optionalDependencies: - vite: 7.3.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + vite: 7.3.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) '@vitest/pretty-format@3.2.6': dependencies: @@ -5761,10 +5680,7 @@ snapshots: mime-types: 3.0.2 negotiator: 1.0.0 - acorn@8.16.0: {} - - acorn@8.17.0: - optional: true + acorn@8.17.0: {} ajv-formats@3.0.1(ajv@8.20.0): optionalDependencies: @@ -6262,7 +6178,7 @@ snapshots: dependencies: magic-string: 0.30.21 mlly: 1.8.2 - rollup: 4.59.0 + rollup: 4.60.4 forwarded@0.2.0: {} @@ -6575,7 +6491,7 @@ snapshots: mlly@1.8.2: dependencies: - acorn: 8.16.0 + acorn: 8.17.0 pathe: 2.0.3 pkg-types: 1.3.1 ufo: 1.6.4 @@ -6731,7 +6647,7 @@ snapshots: dependencies: pg: 8.13.1 - pg-pool@3.13.0(pg@8.20.0): + pg-pool@3.14.0(pg@8.20.0): dependencies: pg: 8.20.0 @@ -6763,13 +6679,13 @@ snapshots: pg@8.20.0: dependencies: - pg-connection-string: 2.12.0 - pg-pool: 3.13.0(pg@8.20.0) - pg-protocol: 1.13.0 + pg-connection-string: 2.14.0 + pg-pool: 3.14.0(pg@8.20.0) + pg-protocol: 1.15.0 pg-types: 2.2.0 pgpass: 1.0.5 optionalDependencies: - pg-cloudflare: 1.3.0 + pg-cloudflare: 1.4.0 pg@8.21.0: dependencies: @@ -6911,37 +6827,6 @@ snapshots: glob: 13.0.6 package-json-from-dist: 1.0.1 - rollup@4.59.0: - dependencies: - '@types/estree': 1.0.8 - optionalDependencies: - '@rollup/rollup-android-arm-eabi': 4.59.0 - '@rollup/rollup-android-arm64': 4.59.0 - '@rollup/rollup-darwin-arm64': 4.59.0 - '@rollup/rollup-darwin-x64': 4.59.0 - '@rollup/rollup-freebsd-arm64': 4.59.0 - '@rollup/rollup-freebsd-x64': 4.59.0 - '@rollup/rollup-linux-arm-gnueabihf': 4.59.0 - '@rollup/rollup-linux-arm-musleabihf': 4.59.0 - '@rollup/rollup-linux-arm64-gnu': 4.59.0 - '@rollup/rollup-linux-arm64-musl': 4.59.0 - '@rollup/rollup-linux-loong64-gnu': 4.59.0 - '@rollup/rollup-linux-loong64-musl': 4.59.0 - '@rollup/rollup-linux-ppc64-gnu': 4.59.0 - '@rollup/rollup-linux-ppc64-musl': 4.59.0 - '@rollup/rollup-linux-riscv64-gnu': 4.59.0 - '@rollup/rollup-linux-riscv64-musl': 4.59.0 - '@rollup/rollup-linux-s390x-gnu': 4.59.0 - '@rollup/rollup-linux-x64-gnu': 4.59.0 - '@rollup/rollup-linux-x64-musl': 4.59.0 - '@rollup/rollup-openbsd-x64': 4.59.0 - '@rollup/rollup-openharmony-arm64': 4.59.0 - '@rollup/rollup-win32-arm64-msvc': 4.59.0 - '@rollup/rollup-win32-ia32-msvc': 4.59.0 - '@rollup/rollup-win32-x64-gnu': 4.59.0 - '@rollup/rollup-win32-x64-msvc': 4.59.0 - fsevents: 2.3.3 - rollup@4.60.4: dependencies: '@types/estree': 1.0.8 @@ -7238,11 +7123,11 @@ snapshots: picocolors: 1.1.1 postcss-load-config: 6.0.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.22.1)(yaml@2.9.0) resolve-from: 5.0.0 - rollup: 4.59.0 + rollup: 4.60.4 source-map: 0.7.6 sucrase: 3.35.1 tinyexec: 0.3.2 - tinyglobby: 0.2.15 + tinyglobby: 0.2.16 tree-kill: 1.2.2 optionalDependencies: postcss: 8.5.14 @@ -7282,7 +7167,7 @@ snapshots: undici-types@6.21.0: {} - undici-types@8.3.0: + undici-types@7.24.6: optional: true unicorn-magic@0.3.0: {} @@ -7320,13 +7205,13 @@ snapshots: - tsx - yaml - vite-node@3.2.4(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0): + vite-node@3.2.4(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0): dependencies: cac: 6.7.14 debug: 4.4.3 es-module-lexer: 1.7.0 pathe: 2.0.3 - vite: 7.3.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + vite: 7.3.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) transitivePeerDependencies: - '@types/node' - jiti @@ -7358,7 +7243,7 @@ snapshots: tsx: 4.22.1 yaml: 2.9.0 - vite@7.3.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0): + vite@7.3.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0): dependencies: esbuild: 0.28.1 fdir: 6.5.0(picomatch@4.0.4) @@ -7367,7 +7252,7 @@ snapshots: rollup: 4.60.4 tinyglobby: 0.2.16 optionalDependencies: - '@types/node': 26.1.0 + '@types/node': 25.8.0 fsevents: 2.3.3 jiti: 2.7.0 lightningcss: 1.30.2 @@ -7416,11 +7301,11 @@ snapshots: - tsx - yaml - vitest@3.2.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0): + vitest@3.2.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0): dependencies: '@types/chai': 5.2.3 '@vitest/expect': 3.2.6 - '@vitest/mocker': 3.2.6(vite@7.3.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0)) + '@vitest/mocker': 3.2.6(vite@7.3.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0)) '@vitest/pretty-format': 3.2.6 '@vitest/runner': 3.2.6 '@vitest/snapshot': 3.2.6 @@ -7438,11 +7323,11 @@ snapshots: tinyglobby: 0.2.16 tinypool: 1.1.1 tinyrainbow: 2.0.0 - vite: 7.3.6(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) - vite-node: 3.2.4(@types/node@26.1.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + vite: 7.3.6(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) + vite-node: 3.2.4(@types/node@25.8.0)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.22.1)(yaml@2.9.0) why-is-node-running: 2.3.0 optionalDependencies: - '@types/node': 26.1.0 + '@types/node': 25.8.0 transitivePeerDependencies: - jiti - less diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index b52bf6747..e0e6d7ddf 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -90,9 +90,13 @@ blockExoticSubdeps: true # - @cipherstash/auth* CipherStash-published auth strategies (NAPI + # WASM-inline variant); also tracked in lockstep # with protect-ffi for the WASM path. +# - @cipherstash/eql CipherStash-published EQL SQL bundle + wire types, +# generated from the same eql-bindings commit as the +# payload format protect-ffi emits; bumped in lockstep. minimumReleaseAgeExclude: - '@prisma-next/*' - '@cipherstash/protect-ffi' - '@cipherstash/protect-ffi-*' - '@cipherstash/auth' - '@cipherstash/auth-*' + - '@cipherstash/eql' diff --git a/skills/stash-cli/SKILL.md b/skills/stash-cli/SKILL.md index ee38879f6..fca5c9559 100644 --- a/skills/stash-cli/SKILL.md +++ b/skills/stash-cli/SKILL.md @@ -308,7 +308,7 @@ Gets a project from zero to installed EQL. It loads an existing `stash.config.ts | `--migration` / `--direct` | Supabase: write a migration file, or run SQL directly | | `--migrations-dir ` | Supabase migrations directory (default `supabase/migrations`) | | `--exclude-operator-family` | Skip operator families (non-superuser roles) | -| `--eql-version <2\|3>` | EQL generation. **Default `2`.** `3` is the native `eql_v3.*` domain schema. | +| `--eql-version <2\|3>` | EQL generation. **Default `2`.** `3` is the native `public.eql_v3_*` domain schema. | | `--latest` | Fetch latest EQL from GitHub instead of the bundled copy (**v2 only**) | | `--database-url ` | One-shot install (see below) | diff --git a/skills/stash-drizzle/SKILL.md b/skills/stash-drizzle/SKILL.md index 15012b410..2b6dc44ab 100644 --- a/skills/stash-drizzle/SKILL.md +++ b/skills/stash-drizzle/SKILL.md @@ -1,11 +1,11 @@ --- name: stash-drizzle -description: Integrate CipherStash encryption with Drizzle ORM using @cipherstash/stack/drizzle. Covers the encryptedType column type, encrypted query operators (eq, like, ilike, gt/gte/lt/lte, between, inArray, asc/desc), schema extraction, batched and/or conditions, EQL migration generation, and the complete Drizzle integration workflow. Use when adding encryption to a Drizzle ORM project, defining encrypted Drizzle schemas, or querying encrypted columns with Drizzle. +description: Integrate CipherStash encryption with Drizzle ORM using @cipherstash/stack-drizzle. Covers the encryptedType column type, encrypted query operators (eq, like, ilike, gt/gte/lt/lte, between, inArray, asc/desc), schema extraction, batched and/or conditions, EQL migration generation, the EQL v3 integration (@cipherstash/stack-drizzle/v3), and the complete Drizzle integration workflow. Use when adding encryption to a Drizzle ORM project, defining encrypted Drizzle schemas, or querying encrypted columns with Drizzle. --- # CipherStash Stack - Drizzle ORM Integration -Guide for integrating CipherStash field-level encryption with Drizzle ORM using `@cipherstash/stack/drizzle`. Provides a custom column type for encrypted fields and query operators that transparently encrypt search values. +Guide for integrating CipherStash field-level encryption with Drizzle ORM using `@cipherstash/stack-drizzle`. Provides a custom column type for encrypted fields and query operators that transparently encrypt search values. ## When to Use This Skill @@ -15,14 +15,18 @@ Guide for integrating CipherStash field-level encryption with Drizzle ORM using - Sorting and filtering on encrypted columns - Generating EQL database migrations - Building Express/Hono/Next.js APIs with encrypted Drizzle queries +- Using EQL v3 typed-schema columns in Drizzle (see "EQL v3 Integration" below) ## Installation ```bash -npm install @cipherstash/stack drizzle-orm +npm install @cipherstash/stack @cipherstash/stack-drizzle drizzle-orm ``` -The Drizzle integration is included in `@cipherstash/stack` and imports from `@cipherstash/stack/drizzle`. +The Drizzle integration ships as its own first-party package, +`@cipherstash/stack-drizzle`, which depends on `@cipherstash/stack`. Install both. +It is distinct from the older, separate `@cipherstash/drizzle` package (which is +`@cipherstash/protect`-based, with different symbol names). ## Database Setup @@ -62,7 +66,7 @@ Use `encryptedType()` to define encrypted columns in Drizzle table schemas: ```typescript import { pgTable, integer, timestamp, varchar } from "drizzle-orm/pg-core" -import { encryptedType } from "@cipherstash/stack/drizzle" +import { encryptedType } from "@cipherstash/stack-drizzle" const usersTable = pgTable("users", { id: integer("id").primaryKey().generatedAlwaysAsIdentity(), @@ -110,7 +114,7 @@ The generic type parameter `` sets the TypeScript type for the decrypted ### 1. Extract Schema from Drizzle Table ```typescript -import { extractEncryptionSchema, createEncryptionOperators } from "@cipherstash/stack/drizzle" +import { extractEncryptionSchema, createEncryptionOperators } from "@cipherstash/stack-drizzle" import { Encryption } from "@cipherstash/stack" // Convert Drizzle table definition to CipherStash schema @@ -366,7 +370,7 @@ Add an `email_encrypted` column **alongside** `email`. Crucially, the encrypted ```typescript // src/db/schema.ts -import { encryptedType } from '@cipherstash/stack/drizzle' +import { encryptedType } from '@cipherstash/stack-drizzle' export const users = pgTable('users', { id: integer('id').primaryKey().generatedAlwaysAsIdentity(), @@ -383,7 +387,7 @@ Update the encryption client to harvest the encrypted columns from the table: ```typescript // src/encryption/index.ts import { Encryption } from '@cipherstash/stack' -import { extractEncryptionSchema } from '@cipherstash/stack/drizzle' +import { extractEncryptionSchema } from '@cipherstash/stack-drizzle' import { users } from '../db/schema' const usersEncryptionSchema = extractEncryptionSchema(users) @@ -623,7 +627,7 @@ import { eq } from "drizzle-orm" import { drizzle } from "drizzle-orm/postgres-js" import postgres from "postgres" import { pgTable, integer, timestamp, varchar } from "drizzle-orm/pg-core" -import { encryptedType, extractEncryptionSchema, createEncryptionOperators, EncryptionOperatorError, EncryptionConfigError } from "@cipherstash/stack/drizzle" +import { encryptedType, extractEncryptionSchema, createEncryptionOperators, EncryptionOperatorError, EncryptionConfigError } from "@cipherstash/stack-drizzle" import { Encryption } from "@cipherstash/stack" // Schema @@ -690,7 +694,7 @@ Individual operators (e.g., `eq()`, `gte()`, `like()`) throw errors when invoked - **`EncryptionConfigError`** — thrown for configuration issues (e.g., using `like` on a column without `freeTextSearch: true`). ```typescript -import { createEncryptionOperators, EncryptionOperatorError, EncryptionConfigError } from "@cipherstash/stack/drizzle" +import { createEncryptionOperators, EncryptionOperatorError, EncryptionConfigError } from "@cipherstash/stack-drizzle" class EncryptionOperatorError extends Error { context?: { @@ -710,3 +714,82 @@ class EncryptionConfigError extends Error { ``` Encryption client operations return `Result` objects with `data` or `failure`. + +## EQL v3 Integration (`@cipherstash/stack-drizzle/v3`) + +Everything above covers the v2 integration (`@cipherstash/stack-drizzle`). The **EQL v3** typed schema has its own Drizzle integration on the `@cipherstash/stack-drizzle/v3` subpath. In v3 every encrypted column is a concrete Postgres domain (`public.eql_v3_text_search`, `public.eql_v3_integer_ord`, ...) whose query capabilities are fixed by the type — there is no `equality: true` / `freeTextSearch: true` config object. See the `stash-encryption` skill's "EQL v3 Typed Schema" section for the full `types` catalog and capability suffixes (`Eq`, `Ord`/`OrdOre`, `Match`, `Search`). + +Exports: `types` (Drizzle-native column factories mirroring the `@cipherstash/stack/eql/v3` namespace), `makeEqlV3Column`, `getEqlV3Column`, `isEqlV3Column`, `extractEncryptionSchemaV3`, `createEncryptionOperatorsV3`, `EncryptionOperatorError`, and the codec helpers `v3ToDriver` / `v3FromDriver` / `EqlV3CodecError`. + +### Schema, Client, and Operators + +```typescript +import { pgTable, integer } from "drizzle-orm/pg-core" +import { EncryptionV3 } from "@cipherstash/stack/v3" +import { + types, + extractEncryptionSchemaV3, + createEncryptionOperatorsV3, +} from "@cipherstash/stack-drizzle/v3" + +const users = pgTable("users", { + id: integer("id").primaryKey().generatedAlwaysAsIdentity(), + email: types.TextSearch("email"), // equality + order/range + free-text + age: types.IntegerOrd("age"), // equality + order/range +}) + +const usersSchema = extractEncryptionSchemaV3(users) +const client = await EncryptionV3({ schemas: [usersSchema] }) +const ops = createEncryptionOperatorsV3(client) +``` + +Each `types.*` factory emits its domain as the column's SQL type, so `drizzle-kit generate` produces `ADD COLUMN email public.eql_v3_text_search` etc. Install the EQL v3 SQL first with `stash eql install --eql-version 3` (direct install only for v3 — the v2 `generate-eql-migration` Drizzle path is not supported yet). + +`makeEqlV3Column(builder)` wraps a column builder from `@cipherstash/stack/eql/v3` (e.g. `makeEqlV3Column(v3types.TextEq("email"))`) — `types.TextEq("email")` from the drizzle subpath is shorthand for the same thing. + +### Insert, Query, Decrypt + +The Drizzle column stores the encrypted EQL envelope, so encrypt models before insert and decrypt after select — passing the extracted schema table: + +```typescript +// Insert +const enc = await client.bulkEncryptModels( + [{ email: "alice@example.com", age: 30 }], + usersSchema, +) +if (!enc.failure) await db.insert(users).values(enc.data) + +// Query — operators auto-encrypt their plaintext operands +const rows = await db.select().from(users) + .where(await ops.and( + ops.matches(users.email, "alice"), // fuzzy free-text token match + ops.between(users.age, 18, 65), + )) + .orderBy(ops.asc(users.age)) + +// Decrypt — v3 decryptModel/bulkDecryptModels take the schema table +const dec = await client.bulkDecryptModels(rows, usersSchema) +``` + +### Operators + +| Operator | Required capability (domain suffix) | +|---|---| +| `eq`, `ne`, `inArray`, `notInArray` | equality (`Eq`, `Ord`, `OrdOre`, `TextSearch`) | +| `gt`, `gte`, `lt`, `lte`, `between`, `notBetween`, `asc`, `desc` | order/range (`Ord`, `OrdOre`, `TextSearch`) | +| `matches` | fuzzy free-text token match (`TextMatch`, `TextSearch`) | +| `contains` | exact encrypted-JSONB containment (`Json`) | +| `and`, `or` | combinators — accept lazy (un-awaited) operators and `undefined`, resolve concurrently | +| `isNull`, `isNotNull`, `not`, `exists`, `notExists` | Drizzle passthroughs, no encryption | + +Differences from the v2 operators to know about: + +- **`like` / `ilike` do not exist — by design.** v3 free-text search is tokenised bloom matching, not SQL pattern matching; `matches(col, needle)` is the free-text operator. It is fuzzy (order- and multiplicity-insensitive) and one-sided (a match may be a false positive, a non-match never is). Don't pass `%` wildcards. +- **`matches` is fuzzy free-text, `contains` is exact JSON containment — two distinct operators (#617).** `matches(col, needle)` requires a `TextMatch` / `TextSearch` column and throws `EncryptionOperatorError` (`requires free-text search`) otherwise. `contains(col, subdoc)` requires a `types.Json` column and throws (`requires JSON containment`) otherwise. +- **`contains` on a `types.Json` column** answers exact encrypted-JSONB containment: `contains(col, { roles: ['admin'] })` matches every row whose document contains that sub-object (jsonb `@>` semantics, no false positives; array containment is position-independent). It emits the `@>` operator with a `query_jsonb` needle — a `Json` column carries no `eq` / ordering, so those operators throw on it. +- **No plaintext-column fallback.** Every v3 operator requires an encrypted v3 column and throws `EncryptionOperatorError` otherwise. Use regular Drizzle operators for non-encrypted columns. +- A `null` operand throws — use `isNull()` / `isNotNull()` for NULL checks. +- `inArray` / `notInArray` reject an empty list, and encrypt the whole list in a single `encryptQuery` batch crossing. +- `matches` rejects a needle shorter than the match tokenizer's token length, and `contains` rejects an empty-object needle (either would otherwise silently match every row). +- Operators gate on the column's capabilities and throw `EncryptionOperatorError` (with `context.columnName` / `tableName` / `operator`) when the domain can't answer the operator. This `EncryptionOperatorError` is exported from `@cipherstash/stack-drizzle/v3` and is deliberately separate from the v2 class of the same name; there is no `EncryptionConfigError` on the v3 path. +- Every operator takes an optional trailing `{ lockContext, audit }` argument; `createEncryptionOperatorsV3(client, { lockContext, audit })` sets defaults applied to every operand encryption. diff --git a/skills/stash-encryption/SKILL.md b/skills/stash-encryption/SKILL.md index f890f3eab..a90b25b7d 100644 --- a/skills/stash-encryption/SKILL.md +++ b/skills/stash-encryption/SKILL.md @@ -1,6 +1,6 @@ --- name: stash-encryption -description: Implement field-level encryption with @cipherstash/stack. Covers schema definition, encrypt/decrypt operations, searchable encryption (equality, free-text, range, JSON), bulk operations, model operations, identity-aware encryption with LockContext, multi-tenant keysets, and the full TypeScript type system. Use when adding encryption to a project, defining encrypted schemas, or working with the CipherStash Encryption API. +description: Implement field-level encryption with @cipherstash/stack. Covers schema definition, encrypt/decrypt operations, searchable encryption (equality, free-text, range, JSON), bulk operations, model operations, identity-aware encryption with LockContext, multi-tenant keysets, the EQL v3 typed schema (concrete Postgres domain columns and the strongly-typed EncryptionV3 client), and the full TypeScript type system. Use when adding encryption to a project, defining encrypted schemas, or working with the CipherStash Encryption API. --- # CipherStash Stack - Encryption @@ -16,6 +16,7 @@ Comprehensive guide for implementing field-level encryption with `@cipherstash/s - Bulk encrypting/decrypting large datasets - Implementing identity-aware encryption with JWT-based lock contexts - Setting up multi-tenant encryption with keysets +- Using the EQL v3 typed schema (`@cipherstash/stack/eql/v3`) — concrete Postgres domain columns with a strongly-typed client (see "EQL v3 Typed Schema" below) - Migrating from `@cipherstash/protect` to `@cipherstash/stack` ## Installation @@ -117,13 +118,16 @@ The SDK never logs plaintext data. | `@cipherstash/stack` | `Encryption` function, `encryptedTable`, `encryptedColumn`, `encryptedField` (convenience re-exports) | | `@cipherstash/stack/schema` | `encryptedTable`, `encryptedColumn`, `encryptedField`, schema types | | `@cipherstash/stack/identity` | `LockContext` class and identity types | -| `@cipherstash/stack/drizzle` | `encryptedType`, `extractEncryptionSchema`, `createEncryptionOperators` for Drizzle ORM | -| `@cipherstash/stack/supabase` | `encryptedSupabase` wrapper for Supabase | +| `@cipherstash/stack-drizzle` | `encryptedType`, `extractEncryptionSchema`, `createEncryptionOperators` for Drizzle ORM | +| `@cipherstash/stack-supabase` | `encryptedSupabase` wrapper for Supabase | | `@cipherstash/stack/dynamodb` | `encryptedDynamoDB` helper for DynamoDB | | `@cipherstash/stack/encryption` | `EncryptionClient` class, `Encryption` function | | `@cipherstash/stack/errors` | `EncryptionErrorTypes`, `StackError`, error subtypes, `getErrorMessage` | | `@cipherstash/stack/client` | Client-safe exports: schema builders, schema types, `EncryptionClient` type (no native FFI) | | `@cipherstash/stack/types` | All TypeScript types | +| `@cipherstash/stack/eql/v3` | EQL v3 typed schema: `encryptedTable`, `types` namespace, `buildEncryptConfig`, inference types (see "EQL v3 Typed Schema" below) | +| `@cipherstash/stack/v3` | `EncryptionV3` factory, `typedClient`, `TypedEncryptionClient` — plus re-exports of everything in `@cipherstash/stack/eql/v3` | +| `@cipherstash/stack-drizzle/v3` | Drizzle ORM integration for EQL v3 schemas (see the `stash-drizzle` skill) | ## Schema Definition @@ -584,6 +588,196 @@ CREATE TABLE users ( ); ``` +## EQL v3 Typed Schema + +EQL v3 is a newer schema surface where every encrypted column is a **concrete Postgres domain** (`public.eql_v3_`) and its query capabilities are fixed by the column type you pick. There is **no chainable capability tuner** — no `.equality()`, `.freeTextSearch()`, or `.orderAndRange()` — every domain is fully described by its type. The v2 surface documented above (`encryptedColumn` from `@cipherstash/stack/schema`) continues to work unchanged; v3 lives on its own subpaths. + +### Quick Start + +```typescript +import { Encryption } from "@cipherstash/stack" +import { encryptedTable, types } from "@cipherstash/stack/eql/v3" + +const users = encryptedTable("users", { + email: types.TextSearch("email"), +}) + +const client = await Encryption({ schemas: [users] }) + +const encryptResult = await client.encrypt("secret@example.com", { + column: users.email, + table: users, +}) +if (encryptResult.failure) { + // handle encryptResult.failure.message +} + +const decryptResult = await client.decrypt(encryptResult.data) +``` + +`Encryption({ schemas })` auto-detects v3 tables and sets the EQL v3 wire format. **v2 and v3 tables cannot be mixed in one client** — a mixed schema set throws at init. Create separate clients if you need both. + +The v3 `encryptedTable` intentionally shares its name with the v2 builder — the import path picks the model. The returned table is also a column accessor (`users.email`). The JS property name and the DB column name may differ: `createdOn: types.Timestamp("created_at")` reads/writes the `createdOn` property on models but targets the `created_at` column in the database. + +### The `types` Namespace + +Each factory in `types` maps 1:1 to a Postgres domain named `public.eql_v3_`. The naming rule: strip the `eql_v3_` prefix and PascalCase each underscore-separated segment. So `types.TextSearch` builds a `public.eql_v3_text_search` column, `types.IntegerOrd` builds `public.eql_v3_integer_ord`, and `types.Timestamp` builds `public.eql_v3_timestamp`. + +**Capability suffixes:** + +| Suffix | Capabilities | Query types | +|---|---|---| +| _(none)_ | Storage only — encrypt/decrypt, no queries | — | +| `Eq` | Equality | `'equality'` | +| `Ord` / `OrdOre` | Equality + ordering/range | `'equality'`, `'orderAndRange'` | +| `Match` (text only) | Free-text containment only | `'freeTextSearch'` | +| `Search` (text only) | Equality + ordering/range + free-text | all three | +| `Json` (no suffix) | Encrypted-JSONB containment queries (JSONPath selector: not yet, see #623) | `'searchableJson'` | + +**Domain families and plaintext types:** + +| Family | Factories | Plaintext (TypeScript) type | +|---|---|---| +| `Integer`, `Smallint`, `Numeric`, `Real`, `Double` | base, `Eq`, `Ord`, `OrdOre` | `number` | +| `Bigint` | base, `Eq`, `Ord`, `OrdOre` | `bigint` (native JS bigint; full i64 range, out-of-range values rejected client-side before the FFI) | +| `Date` | base, `Eq`, `Ord`, `OrdOre` | `Date` (calendar date; time-of-day is truncated) | +| `Timestamp` | base, `Eq`, `Ord`, `OrdOre` | `Date` (time-of-day preserved) | +| `Text` | base, `Eq`, `Match`, `Ord`, `OrdOre`, `Search` | `string` | +| `Boolean` | base only | `boolean` | +| `Json` | `Json` only | a JSON *document* (`JsonDocument`: object, array, or null — NOT a top-level scalar; nested values are any `JsonValue`) | + +Examples: `types.Text("notes")` (storage only), `types.TextEq("username")`, `types.BigintOrd("balance")`, `types.TimestampOrdOre("created_at")`, `types.Boolean("active")`, `types.Json("metadata")`. + +The match index on `Match`/`Search` columns is always emitted with the default configuration — there is no per-column tuning in v3. + +### Free-Text Queries on `types.TextSearch` + +A `TextSearch` column carries all three indexes, and `encryptQuery` with **no explicit `queryType` builds an equality term, not a free-text match** (index inference priority: unique > match > ore). A substring like `"joh"` then matches nothing. Pass `queryType: 'freeTextSearch'` explicitly for substring/token search: + +```typescript +// equality (default): exact value only +await client.encryptQuery("john@example.com", { column: users.email, table: users }) + +// free-text match: substring/token search +await client.encryptQuery("joh", { + column: users.email, + table: users, + queryType: "freeTextSearch", +}) +``` + +### Encrypted-JSONB Queries on `types.Json` + +A `types.Json("metadata")` column encrypts a whole JSON document (a +`JsonDocument`: object, array, or null — not a top-level scalar) to a +`public.eql_v3_json` value. + +**Containment** is the supported query today. Pass a sub-object or sub-array to +`encryptQuery` with `queryType: 'searchableJson'`; it matches documents that +contain the needle (jsonb `@>` semantics). Array containment is a subset test +regardless of element position — `{ roles: ['admin'] }` matches any document +whose `roles` array includes `admin`. + +```typescript +const events = encryptedTable("events", { metadata: types.Json("metadata") }) + +// containment: object needle +await client.encryptQuery({ roles: ["admin"] }, { column: events.metadata, table: events }) +``` + +Through the Drizzle v3 integration this is `ops.contains(col, subObject)` — see +the `stash-drizzle` skill. `types.Json` carries no equality or ordering, so +`eq` / `gt` / `asc` on it throw. + +> **Not yet implemented:** JSONPath selector-with-constraint queries +> (`metadata->'plan' = $1`, `metadata->'age' > $1`) — a distinct third pattern +> the `eql_v3_json` domain supports at the SQL level (`->` / `->>`). Neither the +> query operator nor the selector-string needle typing is wired up yet; tracked +> in [#623](https://github.com/cipherstash/stack/issues/623). + +### Strongly-Typed Client: `EncryptionV3` + +`EncryptionV3` from `@cipherstash/stack/v3` returns a `TypedEncryptionClient` whose method signatures are derived from your schemas — wrong-typed plaintext is rejected at compile time, and query methods only accept queryable columns with `queryType` constrained to the column's capabilities: + +```typescript +import { EncryptionV3, encryptedTable, types } from "@cipherstash/stack/v3" + +const users = encryptedTable("users", { + email: types.TextSearch("email"), + lastLogin: types.TimestampOrd("last_login"), + balance: types.BigintEq("balance"), +}) + +const client = await EncryptionV3({ schemas: [users] }) + +// Plaintext is pinned to the column's domain type: +await client.encrypt("alice@example.com", { table: users, column: users.email }) // string ✓ +await client.encrypt(new Date(), { table: users, column: users.lastLogin }) // Date ✓ +// client.encrypt(42, { table: users, column: users.email }) // ✗ compile error + +const enc = await client.encryptModel( + { id: "u1", email: "alice@example.com", lastLogin: new Date(), balance: 100n }, + users, +) +if (!enc.failure) { + const dec = await client.decryptModel(enc.data, users) + if (!dec.failure) { + dec.data.email // string + dec.data.lastLogin // Date — reconstructed on decrypt + dec.data.balance // bigint + dec.data.id // string — non-schema fields pass through + } +} +``` + +Typed-client notes: + +- The wire format is pinned to EQL v3 (`eqlVersion: 3`); you don't set it yourself. +- Methods: `encrypt`, `encryptQuery`, `encryptModel`, `bulkEncryptModels`, `decrypt`, `decryptModel`, `bulkDecryptModels`, plus `bulkEncrypt`/`bulkDecrypt` passthroughs and `getEncryptConfig`. +- `decryptModel` / `bulkDecryptModels` take the **table as a second argument** and return a plain `Promise>` (not a chainable operation) — pass a lock context as the optional third argument instead of chaining `.withLockContext()`. `Date` columns are reconstructed to real `Date` instances on decrypt; `bigint` columns round-trip as native `bigint`. +- `decrypt` of a single value cannot be strongly typed — a lone ciphertext carries no column identity. +- `encryptQuery` rejects storage-only columns outright at compile time. +- `typedClient(client, ...schemas)` (also exported from `@cipherstash/stack/v3`) wraps an already-built `EncryptionClient` in the typed surface. + +### Database Setup + +Install the EQL v3 SQL with the stash CLI: + +```bash +stash eql install --eql-version 3 +``` + +EQL v3 ships one SQL bundle for every target, including Supabase — no separate Supabase or no-operator-family variants. v3 currently installs via the direct path only (`--drizzle`, `--migration`, `--migrations-dir`, and `--latest` are not supported for v3 yet). + +In migrations, declare each encrypted column as its domain type: + +```sql +CREATE TABLE users ( + id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + email public.eql_v3_text_search, + last_login public.eql_v3_timestamp_ord, + balance public.eql_v3_bigint_eq +); +``` + +### Type Inference + +```typescript +import type { InferPlaintext, InferEncrypted } from "@cipherstash/stack/eql/v3" + +type UserPlaintext = InferPlaintext +// { email: string; lastLogin: Date; balance: bigint } + +type UserEncrypted = InferEncrypted +// { email: Encrypted; lastLogin: Encrypted; balance: Encrypted } +``` + +`V3ModelInput`, `V3EncryptedModel`, and `V3DecryptedModel` (same subpath) are the model-shape helpers the typed client uses: schema-column keys are pinned to the column's plaintext type (nullable fields stay nullable), non-schema keys pass through unchanged. + +### Drizzle ORM + +`@cipherstash/stack-drizzle/v3` provides Drizzle-native v3 column factories, schema extraction, and auto-encrypting query operators. See the `stash-drizzle` skill for the full guide. + ## Rolling Encryption Out to Production Adding a fresh encrypted column to a table you don't yet write to is the easy case — declare it in the schema, run the migration, start writing. The harder case is taking an **existing plaintext column with live data** and turning it into an encrypted one without dropping a write or returning the wrong value mid-cutover. diff --git a/skills/stash-supabase/SKILL.md b/skills/stash-supabase/SKILL.md index a77f3cbeb..d8046c9ad 100644 --- a/skills/stash-supabase/SKILL.md +++ b/skills/stash-supabase/SKILL.md @@ -1,6 +1,6 @@ --- name: stash-supabase -description: Integrate CipherStash encryption with Supabase using @cipherstash/stack/supabase. Covers the encryptedSupabase wrapper, transparent encryption/decryption on insert/update/select, encrypted query filters (eq, like, ilike, gt/gte/lt/lte, in, or, match), identity-aware encryption, and the complete query builder API. Use when adding encryption to a Supabase project, querying encrypted columns, or building secure Supabase applications. +description: Integrate CipherStash encryption with Supabase using @cipherstash/stack-supabase. Covers the encryptedSupabase wrapper, transparent encryption/decryption on insert/update/select, encrypted query filters (eq, like, ilike, gt/gte/lt/lte, in, or, match), identity-aware encryption, and the complete query builder API. Use when adding encryption to a Supabase project, querying encrypted columns, or building secure Supabase applications. --- # CipherStash Stack - Supabase Integration @@ -18,9 +18,12 @@ Guide for integrating CipherStash field-level encryption with Supabase using the ## Installation ```bash -npm install @cipherstash/stack @supabase/supabase-js +npm install @cipherstash/stack @cipherstash/stack-supabase @supabase/supabase-js ``` +The Supabase integration ships as its own first-party package, +`@cipherstash/stack-supabase`, which depends on `@cipherstash/stack`. Install both. + ## Database Schema Encrypted columns must be stored as JSONB in your Supabase database: @@ -70,7 +73,7 @@ const users = encryptedTable("users", { ```typescript import { createClient } from "@supabase/supabase-js" import { Encryption } from "@cipherstash/stack" -import { encryptedSupabase } from "@cipherstash/stack/supabase" +import { encryptedSupabase } from "@cipherstash/stack-supabase" const supabase = createClient( process.env.SUPABASE_URL!, @@ -322,7 +325,7 @@ const { data, error } = await eSupabase ```typescript import { createClient } from "@supabase/supabase-js" import { Encryption } from "@cipherstash/stack" -import { encryptedSupabase } from "@cipherstash/stack/supabase" +import { encryptedSupabase } from "@cipherstash/stack-supabase" import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema" // Schema @@ -394,56 +397,80 @@ type EncryptedSupabaseError = { ## Exported Types -`@cipherstash/stack/supabase` also exports the following types: +`@cipherstash/stack-supabase` also exports the following types: - `EncryptedSupabaseConfig` - `EncryptedSupabaseInstance` - `EncryptedQueryBuilder` - `PendingOrCondition` - `SupabaseClientLike` -- `EncryptedSupabaseV3Config`, `EncryptedSupabaseV3Instance`, `EncryptedQueryBuilderV3` (EQL v3) +- `EncryptedSupabaseV3Options`, `EncryptedSupabaseV3Instance`, `TypedEncryptedSupabaseV3Instance`, `EncryptedQueryBuilderV3`, `EncryptedQueryBuilderV3Untyped`, `V3Schemas` (EQL v3) + +## EQL v3 (native `public.eql_v3_*` domains) -## EQL v3 (native `eql_v3.*` domains) +`encryptedSupabaseV3` is the EQL v3 counterpart of `encryptedSupabase`. +Instead of taking a schema, it **introspects the database at connect time**: +it detects EQL v3 columns by their Postgres domain, derives each column's +encryption config from the domain, and builds the encryption client +internally. Columns are stored in their native `public.eql_v3_*` domain (a +`DOMAIN … AS jsonb` with a CHECK) instead of the v2 composite +`eql_v2_encrypted`. -`encryptedSupabaseV3` is the EQL v3 counterpart of `encryptedSupabase` for -schemas authored with `@cipherstash/stack/eql/v3`. The public surface and call -shape are **identical to v2** — same filter methods, `withLockContext`, -`audit` — only the schema type and the wire encoding differ. Columns are -stored in their native `eql_v3.*` domain (a `DOMAIN … AS jsonb` with a CHECK) -instead of the v2 composite `eql_v2_encrypted`. +The query surface matches v2 — same filter methods, `withLockContext`, +`audit` — with one deliberate fork: encrypted free-text search is `matches()` +(fuzzy bloom token search); `contains()` stays native (exact) containment for +plaintext columns; and `like`/`ilike` on an encrypted column are an approximate +shim that delegates to `matches()` (see below). ### Setup ```typescript -import { Encryption } from "@cipherstash/stack" +import { encryptedSupabaseV3 } from "@cipherstash/stack-supabase" + +// Introspects the database via options.databaseUrl or DATABASE_URL +const es = await encryptedSupabaseV3(supabaseUrl, supabaseKey) +// or wrap an existing client: await encryptedSupabaseV3(supabaseClient, options) + +await es.from("users").insert({ email: "a@b.com", amount: 30 }) +await es.from("users").select("id, email, amount").eq("email", "a@b.com") +await es.from("users").select("id, amount").gte("amount", 10).lte("amount", 100) +``` + +`from(tableName)` takes only the table name — no schema argument. Column +capabilities come from the introspected domains. Introspection needs a direct +Postgres connection (`options.databaseUrl`, defaulting to `DATABASE_URL`), so +the factory cannot run in a Worker or the browser. + +### Optional declared schemas (compile-time types) + +Declaring tables is optional. Passing `schemas` — a record whose keys must +equal each table's name — adds compile-time types and verifies the declared +tables against the database at construction: + +```typescript import { encryptedTable, types } from "@cipherstash/stack/eql/v3" -import { encryptedSupabaseV3 } from "@cipherstash/stack/supabase" +import { encryptedSupabaseV3 } from "@cipherstash/stack-supabase" const users = encryptedTable("users", { - email: types.TextSearch("email"), // eql_v3.text_search — eq + range + free-text - amount: types.IntegerOrd("amount"), // eql_v3.integer_ord — eq + range - joined: types.TimestampOrd("joined_at") // eql_v3.timestamp_ord — eq + range, decrypts to Date + email: types.TextSearch("email"), // public.eql_v3_text_search — eq + range + free-text + amount: types.IntegerOrd("amount"), // public.eql_v3_integer_ord — eq + range + joined: types.TimestampOrd("joined_at") // public.eql_v3_timestamp_ord — eq + range, decrypts to Date }) -const client = await Encryption({ schemas: [users] }) -const es = encryptedSupabaseV3({ encryptionClient: client, supabaseClient: supabase }) +const es = await encryptedSupabaseV3(supabaseUrl, supabaseKey, { + schemas: { users }, +}) -await es.from("users", users).insert({ email: "a@b.com", amount: 30 }) -await es.from("users", users).select("id, email, amount").eq("email", "a@b.com") -await es.from("users", users).select("id, amount").gte("amount", 10).lte("amount", 100) +const { data } = await es.from("users").select("id, email, joined").eq("email", "a@b.com") ``` -Rows default to **exactly** the table's inferred plaintext shape. That keeps -the storage-only-column filter guard active (see below), but it means -plaintext passthrough columns (`id`, `created_at`, …) are not filterable or -insertable at the type level in the default case — pass an explicit row type -that includes them: - -```typescript -type UserRow = { id: number; email: string; amount: number; joined: Date } -const builder = es.from("users", users) -builder.eq("id", 1) // ok — id is in UserRow -``` +A declared table gets a typed builder: rows infer each column's plaintext +type (`types.IntegerOrd` → `number`, `types.TimestampOrd` → `Date`), +storage-only columns are excluded from every filter method, `matches()` is +narrowed to match-indexed columns, and `order()` to plaintext columns. +Undeclared tables behave exactly as with no `schemas` at all. Every v3 column +is fully described by its `types.*` factory — there are no capability or +tuning chains on v3 columns. A JS property may map to a different DB column name (`joined: types.TimestampOrd("joined_at")`) — filters, selects, and results @@ -453,16 +480,17 @@ are translated automatically, and `date`/`timestamp` columns decrypt to real ### Database schema (per-domain columns) Each column is declared with its native domain — the `types.*` member name -maps to the `eql_v3.` domain (strip the `eql_v3.` prefix and PascalCase). -The domains use SQL-standard type names (`integer`, `smallint`, `real`, -`double`, `boolean`, `timestamp`): +maps to the flat `public.eql_v3_` domain (strip the `eql_v3_` prefix and +PascalCase each `_`-separated segment: `types.TextEq` → `public.eql_v3_text_eq`, +`types.IntegerOrd` → `public.eql_v3_integer_ord`). The domains use SQL-standard +type names (`integer`, `smallint`, `real`, `double`, `boolean`, `timestamp`): ```sql CREATE TABLE users ( id SERIAL PRIMARY KEY, - email eql_v3.text_search, - amount eql_v3.integer_ord, - joined_at eql_v3.timestamp_ord + email public.eql_v3_text_search, + amount public.eql_v3_integer_ord, + joined_at public.eql_v3_timestamp_ord ); ``` @@ -472,71 +500,75 @@ CREATE TABLE users ( stash eql install --eql-version 3 --supabase ``` -This installs the opclass-stripped v3 bundle (operator classes need superuser, -which Supabase does not grant) and applies the grants for the -`anon` / `authenticated` / `service_role` roles. The vendored bundle is the -`eql-3.0.0-alpha.2` release artifact; it creates two schemas — `eql_v3` (the -column domains and operators) and `eql_v3_internal` (SEM internals) — and the -installer applies the role grants to both. - -**Manual step (same class of requirement as v2's `eql_v2`):** add `eql_v3` to -the project's **Exposed schemas** (Dashboard → Settings → API → Exposed -schemas). This puts the `eql_v3` operators on PostgREST's search_path so bare -`col = term` filters resolve to the encrypted comparison. **If the schema is -not exposed, the operators do not error — they silently fall back to base -jsonb comparison and return wrong rows.** After changing the setting, verify -with a known-value round-trip: insert a row, filter for it by an encrypted -column, and assert the hit. +Since eql-3.0.0 there is **one** v3 SQL artifact for every target — there is +no separate Supabase variant. The bundle's only superuser-requiring +statements (the ORE operator class/family) skip themselves when the install +role lacks the privilege, and the bundle then disables the ORE-opclass-backed +domains it cannot support. `--supabase` changes one thing: it additionally +applies the role grants for `anon` / `authenticated` / `service_role` to the +two schemas the bundle creates — `eql_v3` (the operator-backing functions) +and `eql_v3_internal` (SEM internals). Without the grants, encrypted queries +fail loudly with a permission error (e.g. `permission denied for schema +eql_v3_internal`). -Expose `eql_v3` **only** — do NOT expose `eql_v3_internal`. The internals -schema exists precisely so that only the column domains are exposed (e.g. -Supabase's Table-Builder type picker shows just the domains). It still needs — -and receives — the role grants; grants and exposure are independent. +No **Exposed schemas** change is needed for v3: the column domains and their +operators live in `public`, so bare `col = term` filters resolve under +Supabase's default PostgREST configuration. Do not expose `eql_v3_internal`. ### v3-specific behaviour All envelopes (stored payloads and filter operands) are versioned `v: 3`. -- **INTERIM — filter operands are full envelopes.** This is a workaround, not - the design (tracked as Linear **CIP-3402**). Why it is required today: every - `eql_v3.*` domain CHECK requires the storage keys (`v`/`i`/`c` plus the - domain's index terms), and the SQL operators coerce their operand into the - domain — so the adapter encrypts each filter value with the full storage - path. The call shape is unchanged. - - **Security caveat:** query terms are meant to be index-terms-only by design, - but a full-envelope operand carries a real decryptable ciphertext `c` plus - **all** of the column's index terms, and PostgREST filters travel in GET - query strings — so these envelopes can land in URL logs, intermediate - proxies, and Supabase request logs. The planned fix is an EQL-side term-only - scalar query envelope (the scalar analog of `eql_v3.jsonb_query`); once it - ships, operands stop carrying ciphertext. -- **`like`/`ilike` are emitted as PostgREST `cs`** (`@>` bloom-filter - containment) — the v3 domains define no LIKE operator. Match is tokenized - and downcased, so `like` and `ilike` behave identically; don't include `%` - wildcards in the pattern. -- **INTERIM — free-text search needs `include_original: false`** on the - column's match index - (`types.TextSearch("email").freeTextSearch({ include_original: false })`) - for substring patterns to match. With the default `include_original: true`, - the full-envelope operand's bloom carries the whole pattern as an extra - token that only matches when the pattern equals the stored value. This is a - symptom of the same full-envelope interim mechanism above and goes away with - the term-only query envelope (CIP-3402). +- **`select('*')` (and bare `select()`) works on v3** — it expands to the + introspected column list. (v2 has no column list to expand, so it still + requires explicit columns.) +- **Encrypted free-text search is `matches()`, not `contains()`/`like`/`ilike`.** + The v3 domains define no LIKE operator — encrypted free-text search is fuzzy + bloom-filter token matching (PostgREST `cs` / SQL `@>`): one-sided (a match + may be a false positive, a non-match never is) and order-/multiplicity- + insensitive, where `%` is tokenized like any other character. `matches(col, + needle)` is the operator; `contains()` on an encrypted column throws an error + pointing at `matches()`. `contains()` is reserved for native (exact) + jsonb/array containment on plaintext columns, which pass through unchanged. +- **`like`/`ilike` on an encrypted column are an approximate compatibility + shim** delegating to `matches()`: leading/trailing `%` are stripped and the + residual term is fuzzy-matched (same `cs` wire, plus a one-time warning). + Results are APPROXIMATE — case-insensitive, one-sided, and anchoring is not + honored. A pattern with an internal `%` or any `_` cannot be approximated and + throws; call `matches()` directly to make the fuzzy intent explicit. On + plaintext columns `like`/`ilike` stay real SQL LIKE. +- **`matches()` matches substrings.** The search term blooms to its own + trigrams, and a row matches when the stored value's bloom contains all of + them — so any substring of at least 3 characters (the tokenizer's + `token_length`) matches. Shorter terms bloom to nothing and would match every + row, so they are rejected with an error rather than answered. +- **INTERIM — filter operands are full storage envelopes.** EQL ships + term-only query domains (`eql_v3.query_`, which accept envelopes with + no ciphertext) and the encryption client can mint those narrowed terms, but + PostgREST has no syntax to cast a filter value — an uncast operand can only + reach the `jsonb` operator overload, which coerces it into the storage + domain, whose CHECK requires ciphertext. So the adapter still encrypts each + filter value with the full storage path. The call shape is unchanged. + + **Security caveat:** query terms are meant to be index-terms-only by + design, but a full-envelope operand carries a real decryptable ciphertext + `c` plus **all** of the column's index terms, and PostgREST filters travel + in GET query strings — so these envelopes can land in URL logs, + intermediate proxies, and Supabase request logs. The remaining gap is + PostgREST operand casting; an adapter-side fix is tracked. +- **No `ORDER BY` on encrypted v3 columns** — including the range-capable + ones. PostgREST cannot emit `ORDER BY eql_v3.ord_term(col)`, and a bare + `ORDER BY` would silently sort the raw ciphertext envelope, so the builder + rejects `order()` on any encrypted column with a clear error. Range + *filtering* (`gte`/`lte`/…) works. Order by a plaintext column, or sort + application-side after decrypting. - **Storage-only domains are not filterable** (e.g. `types.Boolean`, - `types.Text`): a filter (including `.match()`) on one is a type error, and - always a clear runtime error. + `types.Text`): a filter (including `.match()`) on one is a type error on a + declared table, and always a clear runtime error. `.is(column, null)` + remains available. - **Null filter values are rejected** with a pointer to `.is(column, null)` — a null cannot be encrypted into an operand. -### Shared caveats (identical to v2) - -- **No `ORDER BY` on encrypted columns** — operator families need superuser, - which Supabase lacks. Range *filtering* (`gte`/`lte`/…) works. (OPE index - terms that are natively orderable — btree + `ORDER BY` on Supabase — are in - active development; out of scope here.) -- **Operator visibility requires the exposed schema + grants** (above). - ## Migrating an Existing Column to Encrypted The hard case: a Supabase table that already exists with live data in a plaintext column you want to encrypt. You can't just change the column type — that would drop the data. diff --git a/turbo.json b/turbo.json index 6bfd9160b..64780c60d 100644 --- a/turbo.json +++ b/turbo.json @@ -22,6 +22,11 @@ "dependsOn": ["^build", "build"], "inputs": ["$TURBO_DEFAULT$", ".env*"], "cache": false + }, + "test:integration": { + "dependsOn": ["^build", "build"], + "inputs": ["$TURBO_DEFAULT$", ".env*"], + "cache": false } } } diff --git a/vitest.shared.ts b/vitest.shared.ts new file mode 100644 index 000000000..068aaec06 --- /dev/null +++ b/vitest.shared.ts @@ -0,0 +1,114 @@ +import { resolve } from 'node:path' + +/** + * Resolve `@cipherstash/test-kit` and the `@cipherstash/stack` public subpaths + * it imports to SOURCE rather than `dist`. + * + * The kit has no build step, and its catalog imports stack through the public + * subpaths (not stack's internal `@/` alias) because packages outside stack — + * `@cipherstash/drizzle`, and the adapter packages after the split — have to be + * able to import it too. Left unaliased, those specifiers resolve to + * `packages/stack/dist`, which would couple `pnpm test` to a prior `pnpm build`. + * The matching compile-time mapping is `packages/test-kit/tsconfig.json` `paths`. + * + * Spread into each package's vitest config rather than copied, so the two + * cannot drift: + * + * import { sharedAlias } from '../../vitest.shared' + * resolve: { alias: { ...sharedAlias, '@/': … } } + */ +const repoRoot = __dirname + +export const sharedAlias: Record = { + // Longest specifiers first: Vite alias keys are prefix-matched in order. + '@cipherstash/test-kit/suite': resolve( + repoRoot, + 'packages/test-kit/src/run-family-suite.ts', + ), + '@cipherstash/test-kit/catalog': resolve( + repoRoot, + 'packages/test-kit/src/catalog.ts', + ), + '@cipherstash/test-kit/integration-clerk': resolve( + repoRoot, + 'packages/test-kit/src/integration/clerk.ts', + ), + '@cipherstash/test-kit': resolve(repoRoot, 'packages/test-kit/src/index.ts'), + '@cipherstash/stack/eql/v3': resolve( + repoRoot, + 'packages/stack/src/eql/v3/index.ts', + ), + '@cipherstash/stack/schema': resolve( + repoRoot, + 'packages/stack/src/schema/index.ts', + ), + '@cipherstash/stack/v3': resolve( + repoRoot, + 'packages/stack/src/encryption/v3.ts', + ), + // The core↔adapter seam, consumed by the split adapter packages. + '@cipherstash/stack/adapter-kit': resolve( + repoRoot, + 'packages/stack/src/adapter-kit.ts', + ), + '@cipherstash/stack/encryption': resolve( + repoRoot, + 'packages/stack/src/encryption/index.ts', + ), + '@cipherstash/stack/types': resolve( + repoRoot, + 'packages/stack/src/types-public.ts', + ), + '@cipherstash/stack/errors': resolve( + repoRoot, + 'packages/stack/src/errors/index.ts', + ), + '@cipherstash/stack/identity': resolve( + repoRoot, + 'packages/stack/src/identity/index.ts', + ), + // The Supabase adapter now lives in its own package (was + // `@cipherstash/stack/supabase`); resolve it to source too. + '@cipherstash/stack-supabase': resolve( + repoRoot, + 'packages/stack-supabase/src/index.ts', + ), + // The Drizzle adapter package (was `@cipherstash/stack/drizzle` + + // `@cipherstash/stack/eql/v3/drizzle`). `/v3` first — longest prefix wins. + '@cipherstash/stack-drizzle/v3': resolve( + repoRoot, + 'packages/stack-drizzle/src/v3/index.ts', + ), + '@cipherstash/stack-drizzle': resolve( + repoRoot, + 'packages/stack-drizzle/src/index.ts', + ), + // Bare entry LAST: it is a prefix of every subpath above, and Vite matches in + // order, so the subpaths must win first. Both sibling tsconfigs map bare + // `@cipherstash/stack` → `src/index.ts`; without the runtime match here a + // consumer importing the bare specifier would fall through to + // `packages/stack/dist`, re-coupling `pnpm test` to a prior `pnpm build`. + '@cipherstash/stack': resolve(repoRoot, 'packages/stack/src/index.ts'), +} + +/** + * The aliases needed to load stack's SOURCE (not just its public subpaths) from a + * vitest config: stack's own internal `@/` alias — which its source uses and which + * therefore leaks into any package that source-resolves it — plus the wasm-inline + * stubs for the two `/wasm-inline` subpaths Vitest cannot resolve. All resolve to + * fixed locations under `packages/stack`, so they are shared here rather than + * copy-pasted into every package's vitest config. + * + * Spread AFTER `sharedAlias`: `resolve: { alias: { ...sharedAlias, ...stackSourceAlias } }`. + */ +export const stackSourceAlias: Record = { + '@/': `${resolve(repoRoot, 'packages/stack/src')}/`, + '@cipherstash/protect-ffi/wasm-inline': resolve( + repoRoot, + 'packages/stack/__tests__/helpers/stub-protect-ffi-wasm-inline.ts', + ), + '@cipherstash/auth/wasm-inline': resolve( + repoRoot, + 'packages/stack/__tests__/helpers/stub-auth-wasm-inline.ts', + ), +}