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-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-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-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-supabase-adapter.md b/.changeset/eql-v3-supabase-adapter.md new file mode 100644 index 000000000..43e5a4a67 --- /dev/null +++ b/.changeset/eql-v3-supabase-adapter.md @@ -0,0 +1,65 @@ +--- +'@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` still matches only when the needle equals the stored value +or is exactly the tokenizer's window (3 characters): the operand is a storage +envelope whose bloom carries the whole needle as an `include_original` token. +This is shared with v3 Drizzle's `contains` and tracked upstream in EQL. + +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/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/supabase-in-list-operands.md b/.changeset/supabase-in-list-operands.md new file mode 100644 index 000000000..dfd1fb2e5 --- /dev/null +++ b/.changeset/supabase-in-list-operands.md @@ -0,0 +1,74 @@ +--- +'@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. + +**`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/.github/actions/require-cs-secrets/action.yml b/.github/actions/require-cs-secrets/action.yml new file mode 100644 index 000000000..55b39f1dc --- /dev/null +++ b/.github/actions/require-cs-secrets/action.yml @@ -0,0 +1,43 @@ +name: Require CipherStash secrets +description: >- + Fail the job when any CS_* credential is missing. The live test suites gate + themselves on these vars (vitest `describe.skip`, Deno `test.ignore`), so a + rotated / cleared / fork-PR-absent secret would make them silently skip and + let CI go green with ZERO live coverage. This turns that silent skip into a + loud failure. Requires the repo to be checked out first (local action path). + +inputs: + workspace-crn: + description: secrets.CS_WORKSPACE_CRN + required: true + client-id: + description: secrets.CS_CLIENT_ID + required: true + client-key: + description: secrets.CS_CLIENT_KEY + required: true + client-access-key: + description: secrets.CS_CLIENT_ACCESS_KEY + required: true + +runs: + using: composite + steps: + - name: Assert CS_* secrets are present + shell: bash + env: + CS_WORKSPACE_CRN: ${{ inputs.workspace-crn }} + CS_CLIENT_ID: ${{ inputs.client-id }} + CS_CLIENT_KEY: ${{ inputs.client-key }} + CS_CLIENT_ACCESS_KEY: ${{ inputs.client-access-key }} + run: | + missing=0 + for v in CS_WORKSPACE_CRN CS_CLIENT_ID CS_CLIENT_KEY CS_CLIENT_ACCESS_KEY; do + if [ -z "${!v}" ]; then + echo "::error::Required secret $v is not set on this runner — live test suites would silently skip." + missing=1 + fi + done + if [ "$missing" -ne 0 ]; then + exit 1 + fi diff --git a/.github/workflows/fta-v3.yml b/.github/workflows/fta-v3.yml index 541ffc33c..15b2c1f9d 100644 --- a/.github/workflows/fta-v3.yml +++ b/.github/workflows/fta-v3.yml @@ -12,6 +12,10 @@ on: - 'main' paths: - 'packages/stack/src/eql/v3/**' + # 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 +23,7 @@ on: - "**" paths: - 'packages/stack/src/eql/v3/**' + - 'packages/stack/src/schema/match-defaults.ts' - 'packages/stack/package.json' - '.github/workflows/fta-v3.yml' diff --git a/.github/workflows/prisma-example-readme-e2e.yml b/.github/workflows/prisma-example-readme-e2e.yml index 0b6422130..954b0b82f 100644 --- a/.github/workflows/prisma-example-readme-e2e.yml +++ b/.github/workflows/prisma-example-readme-e2e.yml @@ -65,6 +65,16 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # A missing / rotated / fork-PR-absent secret makes the walkthrough skip + # its live steps silently, hiding regressions behind a green job. Fail loud. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Build via turbo so `^build` on `@cipherstash/prisma-next` and # its `@cipherstash/stack` peer is honoured. The test's # `pnpm install` subprocess inside `examples/prisma/` is a no-op diff --git a/.github/workflows/prisma-next-e2e.yml b/.github/workflows/prisma-next-e2e.yml index 00d63c01c..abc7ff82c 100644 --- a/.github/workflows/prisma-next-e2e.yml +++ b/.github/workflows/prisma-next-e2e.yml @@ -67,6 +67,17 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # The global-setup hook hard-errors without CS_WORKSPACE_CRN, but a + # missing sibling secret could still degrade coverage silently — assert + # all four up front so a rotated / fork-PR-absent secret fails loudly. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Write the CS_* credentials and the harness DATABASE_URL into the # example app's .env so the runtime + the `prisma-next migration # apply` invocation in global-setup both pick them up. The harness diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 3a0b5a598..cb7864e92 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -59,6 +59,16 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # Fail loudly if any live-test credential is missing, so the v3 live + # matrix (and every other `describeLive` suite) can't silently skip. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + - name: Type tests (stack) run: pnpm --filter @cipherstash/stack run test:types @@ -68,13 +78,14 @@ jobs: - 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: | @@ -85,6 +96,34 @@ jobs: 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 + # PostgREST for `supabase-v3-pgrest-live.test.ts` — the only suite that + # executes the supabase v3 adapter against a real server rather than a + # mock that records strings. + # + # Started as a STEP, not a `services:` entry. The role it connects as + # (`authenticator`, a non-superuser member of `anon`) does not exist in + # the postgres image, and service containers all start before the repo is + # checked out — so there is no point at which a `services:` PostgREST + # could find it. A step runs after the roles exist, deterministically. + # + # `PGRST_DB_ANON_ROLE: anon` is the whole point: pointing it at the DB + # owner would make every grant check pass vacuously. + - name: Start PostgREST + run: | + PGPASSWORD=password psql -h localhost -U cipherstash -d cipherstash \ + -v ON_ERROR_STOP=1 -f ./local/postgrest-roles.sql + docker run -d --name postgrest --network host \ + -e PGRST_DB_URI="postgres://authenticator:authpass@localhost:5432/cipherstash" \ + -e PGRST_DB_SCHEMAS=public \ + -e PGRST_DB_ANON_ROLE=anon \ + -e PGRST_DB_CHANNEL_ENABLED=true \ + postgrest/postgrest:v12.2.12 + for i in $(seq 1 30); do + curl -sf -o /dev/null http://localhost:3000/ && exit 0 + sleep 1 + done + echo "PostgREST did not become ready"; docker logs postgrest; exit 1 + - name: Create .env file in ./packages/stack/ run: | touch ./packages/stack/.env @@ -93,6 +132,7 @@ jobs: 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 + echo "PGRST_URL=http://localhost:3000" >> ./packages/stack/.env - name: Create .env file in ./packages/protect-dynamodb/ run: | @@ -160,6 +200,16 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # Auth-dependent `e2e/` suites skip themselves without these vars — a + # silent skip would hide regressions behind a green job. Fail loudly. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Run the standalone `e2e/` workspace via turbo so the `^build` # dep on the `test:e2e` task builds cli + wizard first. CLI's own # E2E (`packages/cli/tests/e2e/**`) is covered by the `run-tests` @@ -227,19 +277,17 @@ jobs: - name: Build stack run: pnpm exec turbo run build --filter @cipherstash/stack - # roundtrip.test.ts skips itself (Deno.test.ignore) when any of - # the four CS_* env vars is missing — that's the right behaviour - # for local runs, but in CI a silent skip would mean a rotated / - # cleared secret hides a real WASM regression behind a green job. - # Fail loudly instead. - - name: Assert CS_* secrets are present - run: | - for v in CS_WORKSPACE_CRN CS_CLIENT_ID CS_CLIENT_KEY CS_CLIENT_ACCESS_KEY; do - if [ -z "${!v}" ]; then - echo "::error::Required secret $v is not set on this runner — the WASM smoke test would silently skip." - exit 1 - fi - done + # roundtrip.test.ts skips itself (Deno.test.ignore) when any of the four + # CS_* env vars is missing — fine locally, but in CI a silent skip would + # let a rotated / cleared secret hide a real WASM regression behind a + # green job. Fail loudly instead. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} - name: Run Deno WASM smoke test working-directory: e2e/wasm diff --git a/AGENTS.md b/AGENTS.md index d763293cf..97d513d04 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/eql/v3/drizzle`, `@cipherstash/stack/v3`, `@cipherstash/stack/types`, `@cipherstash/stack/drizzle`, `@cipherstash/stack/dynamodb`, `@cipherstash/stack/supabase`, `@cipherstash/stack/encryption`, `@cipherstash/stack/errors`, `@cipherstash/stack/wasm-inline` - `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` 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/reference/supabase-sdk.md b/docs/reference/supabase-sdk.md index 4698b4e69..aa084aa9f 100644 --- a/docs/reference/supabase-sdk.md +++ b/docs/reference/supabase-sdk.md @@ -9,64 +9,89 @@ 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) +`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. + ```typescript -import { Encryption } from '@cipherstash/stack' -import { encryptedTable, types } from '@cipherstash/stack/eql/v3' import { encryptedSupabaseV3 } from '@cipherstash/stack/supabase' -import { createClient } from '@supabase/supabase-js' - -const users = encryptedTable('users', { - email: types.TextSearch('email'), // eql_v3.text_search - amount: types.IntegerOrd('amount'), // eql_v3.integer_ord -}) -const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_ANON_KEY!) -const client = await Encryption({ schemas: [users] }) -const es = encryptedSupabaseV3({ encryptionClient: client, supabaseClient: supabase }) +// 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 `.contains()` (token containment) and rejects `like`/`ilike` on +encrypted columns (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, `contains()` 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 +115,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 +137,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 +184,61 @@ 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 `contains()`; `like`/`ilike` are rejected** on + encrypted columns with an error naming `contains()`. The v3 domains define + no LIKE operator — free-text search is bloom-filter token containment + (`contains()` → PostgREST `cs` → `@>`), where match is tokenized + + downcased and `%` is tokenized like any other character, so a `like` + pattern is a category error. On plaintext columns `like`/`ilike` (and + native `contains`) pass through unchanged. +- **`contains()` matches exact values, not general substrings.** The match + index always uses its default configuration (`types.TextSearch` takes no + match options), in which the operand's bloom carries the whole needle as an + extra token — so `contains()` matches when the needle equals the stored + value, or is exactly one token (3 characters) long; longer substrings do + not match. Known limitation, tracked upstream in EQL. +- **`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/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/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/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__/installer.test.ts b/packages/cli/src/__tests__/installer.test.ts index 6ed9eb914..d87bfe9da 100644 --- a/packages/cli/src/__tests__/installer.test.ts +++ b/packages/cli/src/__tests__/installer.test.ts @@ -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..fdc5d2ef0 100644 --- a/packages/cli/src/__tests__/supabase-migration.test.ts +++ b/packages/cli/src/__tests__/supabase-migration.test.ts @@ -255,7 +255,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/, ) 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..d45b30f3b 100644 --- a/packages/cli/src/installer/index.ts +++ b/packages/cli/src/installer/index.ts @@ -1,19 +1,37 @@ 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 @@ -22,46 +40,19 @@ function schemaNameFor(eqlVersion: EqlVersion): string { } /** - * 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. + * 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 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 supabaseGrantsFor(eqlVersion: EqlVersion): string { + return eqlVersion === 3 + ? SUPABASE_PERMISSIONS_SQL_V3 + : SUPABASE_PERMISSIONS_SQL } -/** The v2 (`eql_v2`) Supabase grants block. See {@link supabasePermissionsSql}. */ -export const SUPABASE_PERMISSIONS_SQL = supabasePermissionsSql(EQL_SCHEMA_NAME) - -/** - * The v3 Supabase grants block: `eql_v3` AND `eql_v3_internal`. The bundle's - * functions are all SECURITY INVOKER (deliberately, so PostgreSQL can inline - * them), and the `eql_v3` operators call into SEM extractors/comparators that - * live in `eql_v3_internal` — so the calling role itself needs USAGE/EXECUTE - * on the internal schema too, or every encrypted query fails `42501`. - * - * Grants ≠ exposure: only `eql_v3` goes in the dashboard's Exposed schemas; - * `eql_v3_internal` must stay unexposed (the split exists so the Supabase - * Table-Builder type picker shows only the column domains). - */ -export const SUPABASE_PERMISSIONS_SQL_V3 = - supabasePermissionsSql(EQL_V3_SCHEMA_NAME) + - supabasePermissionsSql(EQL_V3_INTERNAL_SCHEMA_NAME) - /** * Get the directory of the current file, supporting both ESM and CJS. */ @@ -306,6 +297,7 @@ export class EQLInstaller { 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 +350,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 +358,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,9 +418,12 @@ 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 @@ -442,8 +431,6 @@ function resolveBundledFilename(options: { eqlVersion?: EqlVersion }): string { if ((options.eqlVersion ?? 2) === 3) { - if (options.supabase || options.excludeOperatorFamily) - return 'cipherstash-encrypt-v3-supabase.sql' return 'cipherstash-encrypt-v3.sql' } if (options.supabase) return 'cipherstash-encrypt-supabase.sql' diff --git a/packages/cli/src/messages.ts b/packages/cli/src/messages.ts index 0e7e418a7..1091495e2 100644 --- a/packages/cli/src/messages.ts +++ b/packages/cli/src/messages.ts @@ -60,6 +60,9 @@ export const messages = { eql: { unknownSubcommand: 'Unknown eql subcommand', }, + eql: { + unknownSubcommand: 'Unknown eql subcommand', + }, db: { unknownSubcommand: 'Unknown db subcommand', /** Warning shown when a deprecated `db ` alias for `eql ` is used. */ 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/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/README.md b/packages/stack/README.md index f3e289bb6..8bd9b8b3d 100644 --- a/packages/stack/README.md +++ b/packages/stack/README.md @@ -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/eql/v3/drizzle` 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. The v2 `@cipherstash/stack/drizzle` module above is unchanged — this is an additive export. + +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/eql/v3/drizzle" +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,8 @@ 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) | +| `@cipherstash/stack/eql/v3/drizzle` | EQL v3 Drizzle integration: `types` column factories, `createEncryptionOperatorsV3`, `extractEncryptionSchemaV3`, `makeEqlV3Column`, `EncryptionOperatorError` | ## 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__/drizzle-operators-bigint.test.ts b/packages/stack/__tests__/drizzle-operators-bigint.test.ts new file mode 100644 index 000000000..6e042a6b9 --- /dev/null +++ b/packages/stack/__tests__/drizzle-operators-bigint.test.ts @@ -0,0 +1,59 @@ +import { PgDialect, pgTable } from 'drizzle-orm/pg-core' +import { describe, expect, it, vi } from 'vitest' +import { createEncryptionOperators, encryptedType } from '@/drizzle' +import type { EncryptionClient } from '@/encryption' + +// 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-v3/bigint.test.ts b/packages/stack/__tests__/drizzle-v3/bigint.test.ts new file mode 100644 index 000000000..7901955e1 --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/bigint.test.ts @@ -0,0 +1,103 @@ +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 '@/eql/v3/drizzle/column' +import { + createEncryptionOperatorsV3, + EncryptionOperatorError, +} from '@/eql/v3/drizzle/operators' +import { types } from '@/eql/v3/drizzle/types' + +// A representative encrypted envelope — what `client.encrypt` actually returns +// and what a bigint column stores. Deliberately NOT a plaintext bigint. +const TERM = { c: 'ct', v: 1 } +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 encrypt = vi.fn(() => chainable(Promise.resolve({ data: TERM }))) + const ops = createEncryptionOperatorsV3({ encrypt }) + const dialect = new PgDialect() + const render = (s: SQL) => dialect.sqlToQuery(s) + return { ops, encrypt, 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, encrypt, 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::jsonb)') + expect(q.params).toEqual([TERM_JSON]) + expect(encrypt.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::jsonb)') + + const between = render(await ops.between(accounts.balance, -5n, 5n)) + expect(between.sql).toContain('eql_v3.gte("accounts"."balance", $1::jsonb)') + expect(between.sql).toContain('eql_v3.lte("accounts"."balance", $2::jsonb)') + + 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/__tests__/drizzle-v3/codec.test.ts b/packages/stack/__tests__/drizzle-v3/codec.test.ts new file mode 100644 index 000000000..4519ee0a0 --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/codec.test.ts @@ -0,0 +1,143 @@ +import { describe, expect, it } from 'vitest' +import { + EqlV3CodecError, + v3FromDriver, + v3ToDriver, +} from '@/eql/v3/drizzle/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/__tests__/drizzle-v3/column.test.ts b/packages/stack/__tests__/drizzle-v3/column.test.ts new file mode 100644 index 000000000..f9397dae3 --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/column.test.ts @@ -0,0 +1,179 @@ +import { pgTable } from 'drizzle-orm/pg-core' +import { describe, expect, it } from 'vitest' +import { types as v3Types } from '@/eql/v3' +import { + EQL_V3_DOMAINS, + getEqlV3Column, + isEqlV3Column, + makeEqlV3Column, +} from '@/eql/v3/drizzle/column' +import { + EQL_V3_DOMAIN_SCHEMA, + eqlTypeSlug as slug, + typedEntries, + V3_MATRIX, +} from '../v3-matrix/catalog' + +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/__tests__/drizzle-v3/exports.test.ts b/packages/stack/__tests__/drizzle-v3/exports.test.ts new file mode 100644 index 000000000..26fbb1ae9 --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/exports.test.ts @@ -0,0 +1,40 @@ +import { describe, expect, it } from 'vitest' +import * as barrel from '@/eql/v3/drizzle' + +// 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/__tests__/drizzle-v3/operators-live-pg.test.ts b/packages/stack/__tests__/drizzle-v3/operators-live-pg.test.ts new file mode 100644 index 000000000..3283cb46b --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/operators-live-pg.test.ts @@ -0,0 +1,904 @@ +import 'dotenv/config' +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, expect, it } from 'vitest' +import { EncryptionV3 } from '@/encryption/v3' +import { + createEncryptionOperatorsV3, + EncryptionOperatorError, + extractEncryptionSchemaV3, + types as v3drizzle, +} from '@/eql/v3/drizzle' +import { makeEqlV3Column } from '@/eql/v3/drizzle/column' +import { installEqlV3IfNeeded } from '../helpers/eql-v3' +import { describeLivePg, LIVE_EQL_V3_PG_ENABLED } from '../helpers/live-gate' +import { + type DomainSpec, + type EqlV3TypeName, + eqlTypeSlug as slug, + typedEntries, + V3_MATRIX, +} from '../v3-matrix/catalog' + +const url = process.env.DATABASE_URL +const sqlClient = LIVE_EQL_V3_PG_ENABLED + ? postgres(url as string, { prepare: false }) + : (undefined as unknown as postgres.Sql) + +const TABLE_NAME = 'protect_ci_v3_drizzle_matrix' +const ACCOUNT_TABLE_NAME = 'protect_ci_v3_drizzle_matrix_accounts' +const RUN = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` +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 + +const matrixEntries = typedEntries(V3_MATRIX) +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' +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 + +const plainValue = (spec: DomainSpec, rowKey: RowKey): PlainValue => + spec.samples[Math.min(ROWS.indexOf(rowKey), spec.samples.length - 1)] + +function comparePlain(left: PlainValue, right: PlainValue): 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 (ORE) 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 + } + throw new Error( + `Unsupported ordered values: ${String(left)}, ${String(right)}`, + ) +} + +function expectedKeysFor( + spec: DomainSpec, + predicate: (value: PlainValue) => boolean, +): RowKey[] { + return ROWS.filter((rowKey) => predicate(plainValue(spec, rowKey))) +} + +/** + * Oracle for the encrypted ORDER BY. Domains with only two samples give ROW_B + * and ROW_C 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. + */ +function sortedKeysFor(spec: DomainSpec, direction: 'asc' | 'desc'): RowKey[] { + return [...ROWS].sort((left, right) => { + const cmp = comparePlain(plainValue(spec, left), plainValue(spec, right)) + if (cmp !== 0) return direction === 'asc' ? cmp : -cmp + return left < right ? -1 : left > right ? 1 : 0 + }) +} + +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 unwrap(result: { data?: T; failure?: { message: string } }): T { + if (result.failure) throw new Error(result.failure.message) + return result.data as T +} + +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 () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + await installEqlV3IfNeeded(sqlClient) + 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 ') + + 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, + nullable_text_eq public.eql_v3_text_eq, + ${columnDefs} + ) + `) + await sqlClient.unsafe(` + CREATE TABLE IF NOT EXISTS ${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(` + CREATE TABLE IF NOT EXISTS ${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 = unwrap( + 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 = unwrap( + 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 () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + await sqlClient`DELETE FROM ${sqlClient(TABLE_NAME)} WHERE test_run_id = ${RUN}` + await sqlClient`DELETE FROM ${sqlClient(ACCOUNT_TABLE_NAME)} WHERE test_run_id = ${RUN}` + await sqlClient`DELETE FROM ${sqlClient(BIGINT_TABLE_NAME)} WHERE test_run_id = ${RUN}` + await sqlClient.end() +}, 30000) + +describeLivePg('v3 drizzle operators (live pg matrix)', () => { + it.each(equalityDomains)( + '%s eq selects the exact row', + async (eqlType, spec) => { + const bound = plainValue(spec, ROW_A) + const rows = await selectRowKeys( + await ops.eq(matrixColumn(eqlType), bound), + ) + // Oracle, not `[ROW_A]`: ROW_C carries a near-miss value for domains with + // a third sample, so an `eq` that over-matches now shows up here. + expect(rows).toEqual( + expectedKeysFor(spec, (value) => comparePlain(value, bound) === 0), + ) + }, + 30000, + ) + + it.each(equalityDomains)( + '%s ne selects the complement rows', + async (eqlType, spec) => { + const bound = plainValue(spec, ROW_A) + const rows = await selectRowKeys( + await ops.ne(matrixColumn(eqlType), bound), + ) + expect(rows).toEqual( + expectedKeysFor(spec, (value) => comparePlain(value, bound) !== 0), + ) + }, + 30000, + ) + + it.each(equalityDomains)( + '%s inArray selects all listed rows', + async (eqlType, spec) => { + const listed = [plainValue(spec, ROW_A), plainValue(spec, ROW_B)] + const rows = await selectRowKeys( + await ops.inArray(matrixColumn(eqlType), listed), + ) + expect(rows).toEqual( + expectedKeysFor(spec, (value) => + listed.some((entry) => comparePlain(value, entry) === 0), + ), + ) + }, + 30000, + ) + + it.each(equalityDomains)( + '%s notInArray excludes listed rows', + async (eqlType, spec) => { + const bound = plainValue(spec, ROW_A) + const rows = await selectRowKeys( + await ops.notInArray(matrixColumn(eqlType), [bound]), + ) + expect(rows).toEqual( + expectedKeysFor(spec, (value) => comparePlain(value, bound) !== 0), + ) + }, + 30000, + ) + + it.each(comparisonDomains)( + '%s %s selects rows by encrypted ordering', + async (eqlType, spec, operator, predicate) => { + const bound = plainValue(spec, ROW_A) + const rows = await selectRowKeys( + await ops[operator](matrixColumn(eqlType), bound), + ) + expect(rows).toEqual( + expectedKeysFor(spec, (value) => predicate(comparePlain(value, bound))), + ) + }, + 30000, + ) + + // The bounds span ROW_A and ROW_B. ROW_C carries a third sample that may sit + // outside that span (most domains) or tie with ROW_B (date, timestamp), so + // membership is computed rather than assumed — with only A and B seeded these + // were `[ROW_A, ROW_B]` and `[]`, which no longer holds. + const spanBounds = (spec: DomainSpec): [PlainValue, PlainValue] => { + const sorted = [plainValue(spec, ROW_A), plainValue(spec, ROW_B)].sort( + comparePlain, + ) + return [sorted[0], sorted[1]] + } + const withinSpan = (spec: DomainSpec) => (value: PlainValue) => { + const [min, max] = spanBounds(spec) + return comparePlain(value, min) >= 0 && comparePlain(value, max) <= 0 + } + + it.each(orderDomains)( + '%s between selects the inclusive range', + async (eqlType, spec) => { + const [min, max] = spanBounds(spec) + const rows = await selectRowKeys( + await ops.between(matrixColumn(eqlType), min, max), + ) + expect(rows).toEqual(expectedKeysFor(spec, withinSpan(spec))) + }, + 30000, + ) + + it.each(orderDomains)( + '%s notBetween excludes the inclusive range', + async (eqlType, spec) => { + const [min, max] = spanBounds(spec) + const rows = await selectRowKeys( + await ops.notBetween(matrixColumn(eqlType), min, max), + ) + expect(rows).toEqual( + expectedKeysFor(spec, (value) => !withinSpan(spec)(value)), + ) + }, + 30000, + ) + + // The spanning cases above put ROW_A and ROW_B inside the range, so on most + // domains only ROW_C proves exclusion. These narrow cases use a single-point + // range at ROW_A's value to prove the operators EXCLUDE regardless of where + // ROW_C falls: `between` must drop ROW_B, `notBetween` must keep it. Without + // these, a `between` that matched everything (or a `notBetween` no-op) passes. + it.each(orderDomains)( + '%s between at a single point excludes the out-of-range row', + async (eqlType, spec) => { + const bound = plainValue(spec, ROW_A) + const rows = await selectRowKeys( + await ops.between(matrixColumn(eqlType), bound, bound), + ) + expect(rows).toEqual( + expectedKeysFor(spec, (value) => comparePlain(value, bound) === 0), + ) + }, + 30000, + ) + + it.each(orderDomains)( + '%s notBetween at a single point keeps the out-of-range row', + async (eqlType, spec) => { + const bound = plainValue(spec, ROW_A) + const rows = await selectRowKeys( + await ops.notBetween(matrixColumn(eqlType), bound, bound), + ) + expect(rows).toEqual( + expectedKeysFor(spec, (value) => comparePlain(value, bound) !== 0), + ) + }, + 30000, + ) + + // `between` returns a two-function conjunction; Drizzle's passthrough `not` + // prepends a bare `not` with no parentheses of its own. Postgres binds NOT + // tighter than AND, so an unparenthesised range would run as + // `(NOT gte(col, bound)) AND lte(col, bound)` — i.e. `col < bound` — instead + // of the range's complement, `col != bound`. + // + // The bound MUST be the SMALLER of the two seeded values. Anchored at the + // larger one, `col < bound` and `col != bound` both select the other row and + // the buggy SQL passes; anchored at the smaller, the buggy SQL selects + // nothing while the correct SQL selects the larger row. Several domains seed + // ROW_A with their maximum sample (`integer_ord` is `[0, -42]`), so keying + // off ROW_A directly would make this test vacuous for them. + it.each(orderDomains)( + '%s not(between(...)) negates the whole range', + async (eqlType, spec) => { + const bound = [plainValue(spec, ROW_A), plainValue(spec, ROW_B)].sort( + comparePlain, + )[0] + const rows = await selectRowKeys( + ops.not(await ops.between(matrixColumn(eqlType), bound, bound)), + ) + expect(rows).toEqual( + expectedKeysFor(spec, (value) => comparePlain(value, bound) !== 0), + ) + // Guards the guard: the expectation must be non-empty, or the buggy + // `col < bound` (which returns nothing) would satisfy it too. + expect(rows.length).toBeGreaterThan(0) + }, + 30000, + ) + + // The secondary `ORDER BY row_key` mirrors the oracle's tie-break. Domains + // with only two samples (date, timestamp) give ROW_B and ROW_C equal values, + // so without it the tied pair's order is arbitrary in Postgres. + it.each(orderDomains)( + '%s asc orders by encrypted order term', + async (eqlType, spec) => { + const rows = (await db + .select({ rowKey: matrixTable.rowKey }) + .from(matrixTable) + .where(drizzleEq(matrixTable.testRunId, RUN)) + .orderBy( + ops.asc(matrixColumn(eqlType)), + drizzleAsc(matrixTable.rowKey), + )) as SelectRow[] + expect(rows.map((row) => row.rowKey)).toEqual(sortedKeysFor(spec, 'asc')) + }, + 30000, + ) + + it.each(orderDomains)( + '%s desc orders by encrypted order term', + async (eqlType, spec) => { + const rows = (await db + .select({ rowKey: matrixTable.rowKey }) + .from(matrixTable) + .where(drizzleEq(matrixTable.testRunId, RUN)) + .orderBy( + ops.desc(matrixColumn(eqlType)), + drizzleAsc(matrixTable.rowKey), + )) as SelectRow[] + expect(rows.map((row) => row.rowKey)).toEqual(sortedKeysFor(spec, 'desc')) + }, + 30000, + ) + + // Needles are driven through the same substring oracle, so each domain gets + // the rows it should. `'ada'` is exactly `token_length`; `'lovelace'` and + // `'grace'` are longer (the suite previously had no `contains` proof above + // the token length at all); `'qqqzzz'` is present in no row, so a `contains` + // that matched everything would fail here rather than pass silently. + it.each( + matchDomains.flatMap(([eqlType, spec]) => + ['ada', 'lovelace', 'grace', 'qqqzzz'].map( + (needle) => [eqlType, spec, needle] as const, + ), + ), + )( + '%s contains %s matches exactly the rows holding it', + async (eqlType, spec, needle) => { + const rows = await selectRowKeys( + await ops.contains(matrixColumn(eqlType), needle), + ) + expect(rows).toEqual( + expectedKeysFor(spec, (value) => + String(value).toLowerCase().includes(needle), + ), + ) + }, + 30000, + ) + + // 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 contains rejects the unanswerable needle %j before encrypting', + async (eqlType, needle) => { + const attempt = ops.contains(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 contains answers the codepoint-sufficient needle %j with no match', + async (eqlType, needle) => { + const rows = await selectRowKeys( + await ops.contains(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.contains(matrixColumn(eqlType), 'ada'), + ) + expect(present.length).toBeGreaterThan(0) + }, + 30000, + ) + + // An `ore`-bearing match column rejects a non-ASCII needle inside ENCRYPTION, + // not in the needle guard. Pinned so the distinction stays visible: the guard + // is about tokenization, this is about the block-ORE term's ASCII-only + // ordering. OPE-backed match domains (text_search) encrypt non-ASCII fine — + // only the `ore`-flavoured ones carry the restriction. + it.each( + matchDomains.filter(([, spec]) => spec.indexes.ore), + )('%s contains rejects a non-ASCII needle in the ORE term, not the guard', async (eqlType) => { + const attempt = ops.contains( + matrixColumn(eqlType), + '\u{1F44D}\u{1F44D}\u{1F44D}', + ) + await expect(attempt).rejects.toThrow(/pure ASCII/) + await expect(attempt).rejects.not.toThrow(/free-text search needs/) + }, 30000) + + it.each( + noEqualityDomains, + )('%s eq rejects unsupported equality', async (eqlType, spec) => { + await expect( + ops.eq(matrixColumn(eqlType), plainValue(spec, ROW_A)), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + }) + + it.each( + noOrderDomains, + )('%s gt rejects unsupported ordering', async (eqlType, spec) => { + await expect( + ops.gt(matrixColumn(eqlType), plainValue(spec, ROW_A)), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + }) + + it.each(noOrderDomains)('%s asc rejects unsupported ordering', (eqlType) => { + expect(() => ops.asc(matrixColumn(eqlType))).toThrow( + EncryptionOperatorError, + ) + }) + + it.each( + noMatchDomains, + )('%s contains rejects unsupported match', async (eqlType, spec) => { + await expect( + ops.contains(matrixColumn(eqlType), plainValue(spec, ROW_A)), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + }) + + // 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('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 = unwrap( + 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/__tests__/drizzle-v3/operators-lock-context-live-pg.test.ts b/packages/stack/__tests__/drizzle-v3/operators-lock-context-live-pg.test.ts new file mode 100644 index 000000000..16c36b6ce --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/operators-lock-context-live-pg.test.ts @@ -0,0 +1,318 @@ +/** + * 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. + * + * Wiring mirrors `lock-context.test.ts` (the current, non-deprecated + * strategy-based flow): the client authenticates as the end user via + * `OidcFederationStrategy` and binds the key to the `sub` claim with a plain + * `.withLockContext({ identityClaim })`. + * + * Gated twice: `describeLivePg` (needs `DATABASE_URL` + CS creds) and an inner + * `USER_JWT` guard (soft-skip, matching the existing identity/lock-context + * suites). 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 — an identity-bound row must not match a + * query issued with no lock context, and must not decrypt without it. The + * symmetric tests alone are insufficient: they drop the context identically on + * both sides, so they stay green even if it were ignored entirely. + * + * A cross-identity non-match (sealed under A, queried under B) still needs a + * second JWT with a different `sub` — a lock context only names the claim while + * ZeroKMS resolves its value from the authenticating token. Tracked separately. + */ +import 'dotenv/config' +import { OidcFederationStrategy } from '@cipherstash/auth' +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, expect, it } from 'vitest' +import { EncryptionV3 } from '@/encryption/v3' +import { + createEncryptionOperatorsV3, + extractEncryptionSchemaV3, +} from '@/eql/v3/drizzle' +import { makeEqlV3Column } from '@/eql/v3/drizzle/column' +import { installEqlV3IfNeeded } from '../helpers/eql-v3' +import { describeLivePg, LIVE_EQL_V3_PG_ENABLED } from '../helpers/live-gate' +import { V3_MATRIX } from '../v3-matrix/catalog' + +const url = process.env.DATABASE_URL +const sqlClient = LIVE_EQL_V3_PG_ENABLED + ? postgres(url as string, { prepare: false }) + : (undefined as unknown as postgres.Sql) + +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 +let userJwt: string | undefined + +function unwrap(result: { data?: T; failure?: { message: string } }): T { + if (result.failure) throw new Error(result.failure.message) + return result.data as T +} + +/** + * 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 no CI run exercises this path — `USER_JWT` is unset in CI (#530) — + * and a wrong message-shape guess would only surface once that secret lands. + */ +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 () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + userJwt = process.env.USER_JWT + if (!userJwt) return + + const crn = process.env.CS_WORKSPACE_CRN + if (!crn) + throw new Error('CS_WORKSPACE_CRN must be set for lock-context tests') + + await installEqlV3IfNeeded(sqlClient) + client = await EncryptionV3({ + schemas: [schema], + config: { + strategy: OidcFederationStrategy.create(crn, () => + Promise.resolve(userJwt as string), + ), + }, + }) + 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 = unwrap>>( + 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 () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + if (userJwt) { + await sqlClient`DELETE FROM ${sqlClient(TABLE_NAME)} WHERE test_run_id = ${RUN}` + } + await sqlClient.end() +}, 30000) + +describeLivePg('v3 drizzle operators with lock context (live pg)', () => { + const skipUnlessJwt = (): boolean => { + if (!userJwt) { + console.log('Skipping lock-context operator test - no USER_JWT provided') + return true + } + return false + } + + it('eq with a matching lock context selects the exact row', async () => { + if (skipUnlessJwt()) return + 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 () => { + if (skipUnlessJwt()) return + 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 = unwrap( + 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 () => { + if (skipUnlessJwt()) return + 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 three tests above all supply the SAME lock context on + // seed and on query, so they cannot distinguish "lock context applied" from + // "lock context silently ignored": a regression that dropped the context from + // the index term would drop it identically on both sides and still match. + // These assert that an identity-bound row is NOT reachable without its + // context — the property the suite exists to protect. + // + // A true CROSS-identity proof (sealed under A, queried under B) needs a + // second JWT with a different `sub`; the lock context only names the claim + // (`['sub']`) while ZeroKMS resolves its value from the authenticating token. + // No `USER_JWT_B` exists, so that remains a follow-up. + it('an identity-bound row does not match an eq issued with no lock context', async () => { + if (skipUnlessJwt()) return + + // The control, in this test rather than a sibling one. `[]` is what a held + // identity boundary and an unseeded fixture both look like, so the empty + // assertion below proves nothing on its own — it only means something + // against a demonstration that the row IS reachable with the context. + const bound = await ops.eq(secretTable.secret, SECRET_A, { + lockContext: IDENTITY_CLAIM as never, + }) + expect(await selectRowKeys(bound)).toEqual([ROW_A]) + + const unbound = await ops.eq(secretTable.secret, SECRET_A) + expect(await selectRowKeys(unbound)).toEqual([]) + }, 30000) + + it('an identity-bound row does not decrypt without its lock context', async () => { + if (skipUnlessJwt()) return + 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 () => { + if (skipUnlessJwt()) return + 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) +}) diff --git a/packages/stack/__tests__/drizzle-v3/operators-null-live-pg.test.ts b/packages/stack/__tests__/drizzle-v3/operators-null-live-pg.test.ts new file mode 100644 index 000000000..325f809f3 --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/operators-null-live-pg.test.ts @@ -0,0 +1,189 @@ +/** + * 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 'dotenv/config' +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, expect, it } from 'vitest' +import { EncryptionV3 } from '@/encryption/v3' +import { + createEncryptionOperatorsV3, + extractEncryptionSchemaV3, +} from '@/eql/v3/drizzle' +import { makeEqlV3Column } from '@/eql/v3/drizzle/column' +import { installEqlV3IfNeeded } from '../helpers/eql-v3' +import { describeLivePg, LIVE_EQL_V3_PG_ENABLED } from '../helpers/live-gate' +import { V3_MATRIX } from '../v3-matrix/catalog' + +const url = process.env.DATABASE_URL +const sqlClient = LIVE_EQL_V3_PG_ENABLED + ? postgres(url as string, { prepare: false }) + : (undefined as unknown as postgres.Sql) + +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 () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + await installEqlV3IfNeeded(sqlClient) + 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 () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + await sqlClient`DELETE FROM ${sqlClient(TABLE_NAME)} WHERE test_run_id = ${RUN}` + await sqlClient.end() +}, 30000) + +describeLivePg('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/__tests__/drizzle-v3/operators.test-d.ts b/packages/stack/__tests__/drizzle-v3/operators.test-d.ts new file mode 100644 index 000000000..564c6615d --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/operators.test-d.ts @@ -0,0 +1,35 @@ +import { describe, expectTypeOf, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import type { EncryptionV3 } from '@/encryption/v3' +import { createEncryptionOperatorsV3 } from '@/eql/v3/drizzle' + +/** + * 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 `{ encrypt }` 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. 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> + + 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 { encrypt } double', () => { + const double = { + encrypt: (_plaintext: never, _opts: never) => ({}) as unknown, + } + expectTypeOf(createEncryptionOperatorsV3).toBeCallableWith(double) + }) +}) diff --git a/packages/stack/__tests__/drizzle-v3/operators.test.ts b/packages/stack/__tests__/drizzle-v3/operators.test.ts new file mode 100644 index 000000000..a8da7abca --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/operators.test.ts @@ -0,0 +1,687 @@ +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 '@/eql/v3/drizzle/column' +import { + createEncryptionOperatorsV3, + EncryptionOperatorError, +} from '@/eql/v3/drizzle/operators' +import { extractEncryptionSchemaV3 } from '@/eql/v3/drizzle/schema-extraction' +import { types } from '@/eql/v3/drizzle/types' +import { + eqlTypeSlug as slug, + typedEntries, + V3_MATRIX, +} from '../v3-matrix/catalog' +import { needleFor } from '../v3-matrix/needle-for' + +const TERM = { c: 'ct', v: 1 } +const TERM_JSON = JSON.stringify(TERM) +const lockContext = { identityClaim: 'user-123' } +const audit = { metadata: { actor: 'test' } } + +type EncryptResult = Promise< + { data: typeof TERM } | { failure: { message: string } } +> + +function chainable(result: EncryptResult) { + const op = result as EncryptResult & { + withLockContext: ReturnType + audit: ReturnType + } + op.withLockContext = vi.fn(() => op) + op.audit = vi.fn(() => op) + return op +} + +function setup( + encryptImpl: (...args: unknown[]) => EncryptResult = async () => ({ + data: TERM, + }), +) { + const encrypt = vi.fn((...args: unknown[]) => chainable(encryptImpl(...args))) + // The factory's `client` parameter is the structural `{ encrypt }` surface, + // so this hand-rolled double satisfies it with no cast (M1). + const client = { encrypt } + const ops = createEncryptionOperatorsV3(client, { lockContext, audit }) + const dialect = new PgDialect() + const render = (s: unknown) => dialect.sqlToQuery(s as SQL) + return { ops, encrypt, render } +} + +type BulkPayload = Array<{ id?: string; plaintext: unknown }> +type BulkResult = Promise< + { data: Array<{ data: typeof TERM }> } | { failure: { message: string } } +> + +/** + * A double for the fuller client surface — one that also exposes `bulkEncrypt`, + * as the real `TypedEncryptionClient` does. `inArray`/`notInArray` should + * prefer it over N single `encrypt` crossings. + */ +function setupBulk( + bulkImpl: (payloads: BulkPayload) => BulkResult = async (payloads) => ({ + data: payloads.map(() => ({ data: TERM })), + }), +) { + const encrypt = vi.fn(() => chainable(Promise.resolve({ data: TERM }))) + const bulkEncrypt = vi.fn((payloads: BulkPayload, ..._rest: unknown[]) => + chainable(bulkImpl(payloads) as never), + ) + const client = { encrypt, bulkEncrypt } + const ops = createEncryptionOperatorsV3(client, { lockContext, audit }) + const dialect = new PgDialect() + const render = (s: unknown) => dialect.sqlToQuery(s as SQL) + return { ops, encrypt, bulkEncrypt, 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) +const storageDomains = matrixEntries.filter( + ([, spec]) => + !spec.indexes.unique && + !spec.indexes.ore && + !spec.indexes.ope && + !spec.indexes.match, +) + +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 full-envelope operand', async (eqlType, spec) => { + const { ops, encrypt, render } = setup() + const q = render(await ops.eq(matrixColumn(eqlType), sampleFor(spec))) + + expect(q.sql).toContain( + `eql_v3.eq("matrix_users"."${slug(eqlType)}", $1::jsonb)`, + ) + expect(q.params).toEqual([TERM_JSON]) + expect(encrypt.mock.calls[0]?.[1]?.column.getName()).toBe(slug(eqlType)) + }) + + it.each(equalityDomains)('%s ne emits eql_v3.neq', async (eqlType, spec) => { + const { ops, encrypt, render } = setup() + const q = render(await ops.ne(matrixColumn(eqlType), sampleFor(spec))) + + expect(q.sql).toContain( + `eql_v3.neq("matrix_users"."${slug(eqlType)}", $1::jsonb)`, + ) + expect(q.params).toEqual([TERM_JSON]) + expect(encrypt.mock.calls[0]?.[1]?.column.getName()).toBe(slug(eqlType)) + }) + + 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::jsonb)') + }) + + 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, encrypt } = setup() + + await ops.eq(first.email, 'ada@example.com') + await ops.eq(second.age, 37) + + expect(encrypt.mock.calls[1]?.[1]?.table.build()).toEqual( + extractEncryptionSchemaV3(second).build(), + ) + }) + + it('passes default lock context and audit to operand encryption', async () => { + const { ops, encrypt } = setup() + await ops.eq(users.nickname, 'ada') + const op = encrypt.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, encrypt } = setup() + const callLockContext = { identityClaim: 'user-456' } + const callAudit = { metadata: { actor: 'override' } } + + await ops.eq(users.nickname, 'ada', { + lockContext: callLockContext, + audit: callAudit, + }) + + const op = encrypt.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, encrypt, render } = setup() + const q = render(await ops[op](matrixColumn(eqlType), sampleFor(spec))) + + expect(q.sql).toContain( + `${fn}("matrix_users"."${slug(eqlType)}", $1::jsonb)`, + ) + expect(q.params).toEqual([TERM_JSON]) + expect(encrypt.mock.calls[0]?.[1]?.column.getName()).toBe(slug(eqlType)) + } + }) + + it.each( + orderDomains, + )('%s between emits a bounded range with two full-envelope 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::jsonb)`, + ) + expect(q.sql).toContain( + `eql_v3.lte("matrix_users"."${slug(eqlType)}", $2::jsonb)`, + ) + 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::jsonb)`, + ) + expect(q.sql).toContain( + `eql_v3.lte("matrix_users"."${slug(eqlType)}", $2::jsonb)`, + ) + 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(async (value) => ({ + data: { p: value } as never, + })) + + const q = render(await ops.between(users.age, -128, 127)) + + expect(q.sql).toBe( + '(eql_v3.gte("users"."age", $1::jsonb) AND eql_v3.lte("users"."age", $2::jsonb))', + ) + 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(async (value) => ({ + data: { p: value } as never, + })) + + 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::jsonb) AND eql_v3.lte("users"."age", $2::jsonb))', + ) + }) + + 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::jsonb) AND eql_v3.lte("users"."age", $2::jsonb))', + ) + }) + + 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 contains emits latest eql_v3.contains with a full-envelope operand', async (eqlType, spec) => { + const { ops, encrypt, render } = setup() + const q = render(await ops.contains(matrixColumn(eqlType), needleFor(spec))) + + expect(q.sql).toContain( + `eql_v3.contains("matrix_users"."${slug(eqlType)}", $1::jsonb)`, + ) + expect(q.params).toEqual([TERM_JSON]) + expect(encrypt.mock.calls[0]?.[1]?.column.getName()).toBe(slug(eqlType)) + }) + + // 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 contains rejects a needle shorter than token_length before encrypting', async (eqlType) => { + const { ops, encrypt } = setup() + await expect(ops.contains(matrixColumn(eqlType), 'ad')).rejects.toThrow( + /at least 3 characters/, + ) + await expect(ops.contains(matrixColumn(eqlType), '')).rejects.toThrow( + EncryptionOperatorError, + ) + expect(encrypt).not.toHaveBeenCalled() + }) + + it('contains accepts a needle exactly at token_length', async () => { + const { ops, render } = setup() + const q = render(await ops.contains(users.email, 'ada')) + expect(q.sql).toContain('eql_v3.contains("users"."email", $1::jsonb)') + }) + + it('negation is expressed through the passthrough Drizzle not operator', async () => { + const { ops, render } = setup() + const q = render(ops.not(await ops.contains(users.email, 'example.com'))) + expect(q.sql).toMatch(/^not /i) + expect(q.sql).toContain('eql_v3.contains("users"."email", $1::jsonb)') + }) + + 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 - storage-only domains', () => { + it.each(storageDomains)('%s eq throws', async (eqlType, spec) => { + const { ops } = setup() + await expect( + ops.eq(matrixColumn(eqlType), sampleFor(spec)), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + }) + + it.each(storageDomains)('%s contains throws', async (eqlType, spec) => { + const { ops } = setup() + await expect( + ops.contains(matrixColumn(eqlType), sampleFor(spec)), + ).rejects.toBeInstanceOf(EncryptionOperatorError) + }) + + it.each(storageDomains)('%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 fans out more than MAX_IN_ARRAY_CONCURRENCY values exactly once', async () => { + const { ops, encrypt, 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)) + expect(encrypt).toHaveBeenCalledTimes(values.length) + expect(encrypt.mock.calls.map(([value]) => value).sort()).toEqual( + [...values].sort(), + ) + }) + + 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 bulkEncrypt crossing', async () => { + const { ops, encrypt, bulkEncrypt, render } = setupBulk() + const values = ['ada', 'grace', 'alan', 'katherine', 'dorothy'] + + const q = render(await ops.inArray(users.nickname, values)) + + expect(bulkEncrypt).toHaveBeenCalledTimes(1) + expect(encrypt).not.toHaveBeenCalled() + expect(bulkEncrypt.mock.calls[0]?.[0]).toEqual( + values.map((plaintext) => ({ plaintext })), + ) + const opts = bulkEncrypt.mock.calls[0]?.[1] as { + column: { getName(): string } + } + expect(opts.column.getName()).toBe('nickname') + expect((q.sql.match(/eql_v3\.eq/g) ?? []).length).toBe(values.length) + expect(q.params).toEqual(values.map(() => TERM_JSON)) + }) + + it('notInArray bulk-encrypts once and ANDs one ne term per value', async () => { + const { ops, bulkEncrypt, render } = setupBulk() + + const q = render(await ops.notInArray(users.nickname, ['ada', 'grace'])) + + expect(bulkEncrypt).toHaveBeenCalledTimes(1) + expect((q.sql.match(/eql_v3\.neq/g) ?? []).length).toBe(2) + expect(q.sql).toContain(' and ') + }) + + it('bulk operand encryption carries the lock context and audit config', async () => { + const { ops, bulkEncrypt } = setupBulk() + + await ops.inArray(users.nickname, ['ada', 'grace']) + + const op = bulkEncrypt.mock.results[0]?.value + expect(op.withLockContext).toHaveBeenCalledWith(lockContext) + expect(op.audit).toHaveBeenCalledWith(audit) + }) + + it('bulk terms keep their positions so each eq term matches its value', async () => { + const terms = [{ c: 'ada' }, { c: 'grace' }] as unknown as Array<{ + data: typeof TERM + }> + const { ops, render } = setupBulk(async () => ({ + data: [{ data: terms[0] as never }, { data: terms[1] as never }], + })) + + const q = render(await ops.inArray(users.nickname, ['ada', 'grace'])) + + expect(q.params).toEqual([ + JSON.stringify(terms[0]), + JSON.stringify(terms[1]), + ]) + }) + + it('a bulk encryption failure is wrapped with operator context', async () => { + const { ops } = setupBulk(async () => ({ + 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, bulkEncrypt } = setupBulk() + + await expect(ops.inArray(users.nickname, ['ada', null])).rejects.toThrow( + /isNull/, + ) + expect(bulkEncrypt).not.toHaveBeenCalled() + }) + + it('a bulk response of the wrong length is rejected rather than silently truncated', async () => { + const { ops } = setupBulk(async () => ({ data: [{ 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( + /bulk 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, bulkEncrypt } = setupBulk() + + await expect(ops.inArray(users.flag, [true])).rejects.toBeInstanceOf( + EncryptionOperatorError, + ) + expect(bulkEncrypt).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 } = setup(async () => ({ + 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('contains on a column without match throws', async () => { + const { ops } = setup() + await expect(ops.contains(users.nickname, 'ada')).rejects.toBeInstanceOf( + EncryptionOperatorError, + ) + }) + + 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.contains(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/__tests__/drizzle-v3/schema-extraction.test.ts b/packages/stack/__tests__/drizzle-v3/schema-extraction.test.ts new file mode 100644 index 000000000..c87790fc3 --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/schema-extraction.test.ts @@ -0,0 +1,111 @@ +import { integer, pgTable } from 'drizzle-orm/pg-core' +import { describe, expect, it } from 'vitest' +import { encryptedTable, types as v3Types } from '@/eql/v3' +import { extractEncryptionSchemaV3 } from '@/eql/v3/drizzle/schema-extraction' +import { types } from '@/eql/v3/drizzle/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/__tests__/drizzle-v3/sql-dialect.test.ts b/packages/stack/__tests__/drizzle-v3/sql-dialect.test.ts new file mode 100644 index 000000000..142b79e58 --- /dev/null +++ b/packages/stack/__tests__/drizzle-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 '@/eql/v3/drizzle/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::jsonb)', + ) + }) + + it('inequality via HMAC', () => { + expect(render(v3Dialect.equality('ne', col, enc))).toBe( + 'eql_v3.neq("users"."x", $1::jsonb)', + ) + }) + + it('comparison via ORE', () => { + expect(render(v3Dialect.comparison('gte', col, enc))).toBe( + 'eql_v3.gte("users"."x", $1::jsonb)', + ) + }) + + 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::jsonb) AND eql_v3.lte("users"."x", $2::jsonb))', + ) + }) + + 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::jsonb) AND eql_v3.lte("users"."x", $2::jsonb))', + ) + }) + + it('contains via two-arg function', () => { + expect(render(v3Dialect.contains(col, enc))).toBe( + 'eql_v3.contains("users"."x", $1::jsonb)', + ) + }) + + 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::jsonb') + // 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::jsonb) AND eql_v3.lte("users"."x", $2::jsonb))', + ) + }) + + 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::jsonb)') + }) + }) + + 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/__tests__/drizzle-v3/types.test-d.ts b/packages/stack/__tests__/drizzle-v3/types.test-d.ts new file mode 100644 index 000000000..e33b4f7a0 --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/types.test-d.ts @@ -0,0 +1,42 @@ +import { describe, expectTypeOf, it } from 'vitest' +import type { types as v3Types } from '@/eql/v3' +import { types } from '@/eql/v3/drizzle/types' +import type { Encrypted } from '@/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/__tests__/drizzle-v3/types.test.ts b/packages/stack/__tests__/drizzle-v3/types.test.ts new file mode 100644 index 000000000..c143fc17c --- /dev/null +++ b/packages/stack/__tests__/drizzle-v3/types.test.ts @@ -0,0 +1,22 @@ +import { describe, expect, it } from 'vitest' +import { types as v3Types } from '@/eql/v3' +import { getEqlV3Column } from '@/eql/v3/drizzle/column' +import { types } from '@/eql/v3/drizzle/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/__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..192b034e8 --- /dev/null +++ b/packages/stack/__tests__/eql-v3-domain-registry.test.ts @@ -0,0 +1,132 @@ +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', +] 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 index bfb8fb556..512741ba8 100644 --- a/packages/stack/__tests__/helpers/eql-v3.ts +++ b/packages/stack/__tests__/helpers/eql-v3.ts @@ -1,95 +1,45 @@ -import { readFile } from 'node:fs/promises' -import { dirname, resolve } from 'node:path' -import { fileURLToPath } from 'node:url' +import { readInstallSql, releaseManifest } from '@cipherstash/eql/sql' 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 +// Staleness is decided by asking the database which EQL release it is running +// and comparing that to the release the pinned @cipherstash/eql ships. Earlier +// revisions probed for a sentinel type (public.eql_v3_text_search, then +// public.eql_v3_timestamp) that was hand-picked to exist only in the newest bundle. +// Every such sentinel decays: the next bundle keeps the type, the check starts +// reporting "current" against a stale install, and the suite silently exercises +// the wrong SQL. eql_v3.version() carries the release identity itself, so this +// needs no maintenance when the pin moves. +// +// The probe has to be its own statement. Postgres resolves function references +// while parsing a statement, before any branch of it runs, so guarding the call +// with CASE WHEN to_regprocedure(...) IS NULL in the same statement still raises +// "schema eql_v3 does not exist" against a database with no EQL v3 — the guard +// only ever succeeds when it is not needed. to_regprocedure() takes the name as +// a string, so on its own it yields NULL rather than raising, and a database +// with no EQL v3 — or with a bundle predating eql_v3.version() — reads as stale +// and gets installed. +async function readEqlV3Version(sql: postgres.Sql): Promise { + const [probe] = await sql<{ present: boolean }[]>` + SELECT to_regprocedure('eql_v3.version()') IS NOT NULL AS present ` - return row?.installed ?? false + if (!probe?.present) return null + + const [row] = await sql< + { version: string }[] + >`SELECT eql_v3.version() AS version` + return row?.version ?? null } /** - * 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. + * Install the EQL v3 SQL bundle shipped by @cipherstash/eql only when the + * target database is not already running that exact release. * - * 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. + * The bundle starts with DROP SCHEMA IF EXISTS eql_v3 CASCADE, so callers must + * never run it unconditionally against a shared test database. */ -export async function installEqlV3IfNeeded( - sql: postgres.Sql, - options?: { supabase?: boolean }, -): Promise { +export async function installEqlV3IfNeeded(sql: postgres.Sql): 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 @@ -100,33 +50,17 @@ export async function installEqlV3IfNeeded( await reserved`SELECT pg_advisory_lock(${EQL_V3_ADVISORY_LOCK_ID})` try { - if (await hasCurrentGenerationEqlV3(reserved)) return + if ((await readEqlV3Version(reserved)) === releaseManifest.eqlVersion) + 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` + // Sent as one multi-statement string: the bundle is ~43k lines and a + // statement-at-a-time client would pay a round-trip per CREATE FUNCTION. + await reserved.unsafe(readInstallSql()) - 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))) { + const installed = await readEqlV3Version(reserved) + if (installed !== releaseManifest.eqlVersion) { 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)', + `EQL v3 installation did not yield the expected release: wanted ${releaseManifest.eqlVersion}, got ${installed ?? 'no eql_v3.version()'}`, ) } } finally { @@ -136,26 +70,3 @@ export async function installEqlV3IfNeeded( 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 index 8ad3675ec..854bfb4dc 100644 --- a/packages/stack/__tests__/helpers/live-gate.ts +++ b/packages/stack/__tests__/helpers/live-gate.ts @@ -23,6 +23,52 @@ export const LIVE_EQL_V3_PG_ENABLED = Boolean( process.env.DATABASE_URL && LIVE_CIPHERSTASH_ENABLED, ) +/** + * True when live credentials AND a `USER_JWT` are configured. The identity / + * lock-context live suites additionally require a `USER_JWT` to bind keys to an + * end-user identity, and SOFT-SKIP (inline `if (!userJwt) return`) when it is + * absent — so a missing/rotated `USER_JWT` lets them skip green in CI. This + * flag lets the live-coverage guard assert that path is actually exercised. + */ +export const LIVE_LOCK_CONTEXT_ENABLED = Boolean( + process.env.USER_JWT && LIVE_CIPHERSTASH_ENABLED, +) + export const describeLive = LIVE_CIPHERSTASH_ENABLED ? describe : describe.skip export const describeLivePg = LIVE_EQL_V3_PG_ENABLED ? describe : describe.skip + +/** + * True when only a Postgres `DATABASE_URL` is configured (no CipherStash creds + * needed — introspection reads the schema, it does not encrypt). + * + * Like the flags above, a false value turns its suites into `describe.skip`, + * which in CI would be a silent whole-suite skip on a green job. That hole is + * closed by `../live-coverage-guard.test.ts`, which asserts THIS flag in CI. + * Any new gate flag added here must be asserted there too. + */ +export const LIVE_PG_ENABLED = Boolean(process.env.DATABASE_URL) + +export const describeLivePgOnly = LIVE_PG_ENABLED ? describe : describe.skip + +/** + * True when a real PostgREST is reachable AND a `DATABASE_URL` is configured. + * + * The supabase v3 adapter talks to PostgREST, not to Postgres — the aliasing + * `prop:db_name::jsonb` casts, the `cs` containment mapping, the quoted + * envelopes inside `or=(…)`, and the full storage envelope every `public.*` + * domain CHECK must accept are all things only a real server can execute. + * Everything else in the repo asserts them as strings against a mock. + * + * NO CipherStash creds: the suite builds structurally-valid envelopes itself + * (the domain CHECKs are structural — `v`/`i`/`c` plus the domain's index + * terms), so it can run wherever the DB-only suites run. It proves the WIRE and + * the GRANTS. Cryptographic round-tripping is `drizzle-v3/operators-live-pg`'s + * job and needs the credentials. + */ +export const LIVE_SUPABASE_PGREST_ENABLED = + Boolean(process.env.PGRST_URL) && LIVE_PG_ENABLED + +export const describeLiveSupabasePgrest = LIVE_SUPABASE_PGREST_ENABLED + ? describe + : describe.skip diff --git a/packages/stack/__tests__/helpers/pgrest.ts b/packages/stack/__tests__/helpers/pgrest.ts new file mode 100644 index 000000000..bedcee766 --- /dev/null +++ b/packages/stack/__tests__/helpers/pgrest.ts @@ -0,0 +1,73 @@ +/** + * 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 '@/supabase/types' + +export function makePostgrestClient(): SupabaseClientLike { + const url = process.env.PGRST_URL + if (!url) { + throw new Error( + 'PGRST_URL is not set — makePostgrestClient() must only be called behind `describeLiveSupabasePgrest`', + ) + } + 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/__tests__/helpers/postgrest-wire.ts b/packages/stack/__tests__/helpers/postgrest-wire.ts new file mode 100644 index 000000000..d08088987 --- /dev/null +++ b/packages/stack/__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 '@/supabase/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/__tests__/helpers/supabase-mock.ts b/packages/stack/__tests__/helpers/supabase-mock.ts new file mode 100644 index 000000000..e799170a9 --- /dev/null +++ b/packages/stack/__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 '@/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/__tests__/helpers/v3-envelope.ts b/packages/stack/__tests__/helpers/v3-envelope.ts new file mode 100644 index 000000000..31c89a15c --- /dev/null +++ b/packages/stack/__tests__/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/__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__/live-coverage-guard.test.ts b/packages/stack/__tests__/live-coverage-guard.test.ts new file mode 100644 index 000000000..1d44370dd --- /dev/null +++ b/packages/stack/__tests__/live-coverage-guard.test.ts @@ -0,0 +1,153 @@ +/** + * Live-coverage guard — a meta-test that is DELIBERATELY NOT wrapped in any + * `describeLive*` gate, so it always runs (in CI and locally). + * + * ## Why this exists + * Every live (network/DB-touching) suite gates itself on the flags exported by + * `./helpers/live-gate`: + * - `LIVE_CIPHERSTASH_ENABLED` — all four CS_* creds present + * - `LIVE_EQL_V3_PG_ENABLED` — the above AND `DATABASE_URL` present + * When a flag is false the suite becomes `describe.skip`. That is correct + * locally, but in CI it means a rotated/cleared secret (or a missing + * `DATABASE_URL`) makes the ENTIRE live matrix silently skip while the job + * still goes GREEN — zero live coverage, no signal. + * + * The `require-cs-secrets` CI action catches missing CS_* secrets, but it + * (a) does NOT check `DATABASE_URL` (the pg-gate input), and (b) only proves + * the ENV is set on the runner, not that the suites actually consumed it and + * ran. This meta-test closes both gaps by asserting the very flags the live + * suites branch on. Because the suites gate on these EXACT flags, proving the + * flags are `true` in CI transitively guarantees the live suites — and their + * `beforeAll` setup — execute rather than skip. A silent whole-matrix skip + * becomes a loud, single-line failure. + * + * ## CI-only enforcement + * Enforcement is scoped to `process.env.CI` (GitHub Actions always sets + * `CI=true`). Locally, with no creds, this test is a no-op so ordinary dev + * runs still pass. See `.github/workflows/tests.yml` — the `run-tests` job runs + * `pnpm run test` on a runner where GitHub injects `CI=true`, and the CS_* + * creds + `DATABASE_URL` are written into `packages/stack/.env` (loaded here + * via `dotenv/config`, exactly as the live suites load them). + * + * ## Import order matters + * `import 'dotenv/config'` MUST come first: in CI the creds live in + * `packages/stack/.env`, and `live-gate` evaluates the flags at module-load + * time. Loading dotenv before importing the gate mirrors what every live suite + * does and ensures the flags reflect the real environment. + * + * ## Layer 2 (execution census) — intentionally NOT added + * A stronger check would assert each critical live file executed its expected + * number of tests with zero skips (e.g. via `--reporter=json` + a script, or a + * vitest `onFinished` hook). It is omitted on purpose: + * - The live suites gate on the SAME flags asserted here, so this Layer-1 + * check already guarantees they run — a census would only re-detect the + * same "did the matrix run" failure it is meant to catch. + * - A per-file count census needs hardcoded expected totals that drift every + * time a domain/case is added, turning a safety net into maintenance debt. + * - It would add an extra CI step / reporter wiring for marginal signal. + * If a future regression is ever a *partial* skip (individual `it.skip` inside + * an enabled suite — a different failure mode than the silent whole-matrix skip + * this guards), extend here with a `--reporter=json` post-run script asserting + * `numPendingTests === 0` for the critical files, rather than hardcoding counts. + */ +import 'dotenv/config' +import { describe, expect, it } from 'vitest' +import { + LIVE_CIPHERSTASH_ENABLED, + LIVE_EQL_V3_PG_ENABLED, + LIVE_LOCK_CONTEXT_ENABLED, + LIVE_PG_ENABLED, + LIVE_SUPABASE_PGREST_ENABLED, +} from './helpers/live-gate' + +// GitHub Actions always sets CI=true; treat any truthy CI as "must run live". +const IN_CI = Boolean(process.env.CI) + +describe('live-coverage guard', () => { + it.runIf(IN_CI)( + 'CI must have CipherStash creds so the live suites do not silently skip', + () => { + expect( + LIVE_CIPHERSTASH_ENABLED, + 'CI must run the live suites — CS_* creds missing (CS_WORKSPACE_CRN / ' + + 'CS_CLIENT_ID / CS_CLIENT_KEY / CS_CLIENT_ACCESS_KEY) → every ' + + '`describeLive` suite becomes describe.skip and the live matrix ' + + 'silently skips while CI stays green.', + ).toBe(true) + }, + ) + + it.runIf(IN_CI)( + 'CI must have DATABASE_URL so the live pg suites do not silently skip', + () => { + expect( + LIVE_EQL_V3_PG_ENABLED, + 'CI must run the live Postgres suites — `LIVE_EQL_V3_PG_ENABLED` is ' + + 'false. This needs the CS_* creds AND a `DATABASE_URL`; a missing ' + + 'DATABASE_URL is the hole the require-cs-secrets action does not ' + + 'cover, and makes every `describeLivePg` suite silently skip.', + ).toBe(true) + }, + ) + + // DEFERRED (follow-up): the CI `USER_JWT` secret is not yet provisioned, so + // enforcing this now would fail CI. Skipped until the secret exists — flip + // back to `it.runIf(IN_CI)` at that point. It still documents the real gap: + // the identity / lock-context live suites soft-skip on a missing USER_JWT, so + // once the secret lands this guard turns a silent whole-suite skip into a + // loud failure (as the CS_*/DATABASE_URL guards already do). + it.skip('CI must have USER_JWT so the lock-context live suites do not silently skip', () => { + expect( + LIVE_LOCK_CONTEXT_ENABLED, + 'CI must run the live lock-context / identity suites — ' + + '`LIVE_LOCK_CONTEXT_ENABLED` is false. This needs the CS_* creds AND ' + + 'a `USER_JWT`; the identity/lock-context suites (e.g. ' + + 'lock-context.test.ts, protect-ops.test.ts, ' + + 'operators-lock-context-live-pg.test.ts) SOFT-SKIP when USER_JWT is ' + + 'absent, so a missing/rotated USER_JWT lets them skip green with no ' + + 'signal — the exact failure mode this guard exists to prevent.', + ).toBe(true) + }) + + it.runIf(IN_CI)( + 'CI must have DATABASE_URL so the pg-only suites do not silently skip', + () => { + expect( + LIVE_PG_ENABLED, + 'CI must run the DB-only suites — `LIVE_PG_ENABLED` is false. This ' + + 'needs only `DATABASE_URL` (no CS_* creds: introspection reads the ' + + 'schema, it does not encrypt), and `.github/workflows/tests.yml` ' + + 'writes it as a literal into packages/stack/.env alongside a Postgres ' + + 'service — so a false value here is a broken workflow, never a valid ' + + 'configuration. It makes every `describeLivePgOnly` suite (e.g. ' + + 'supabase-v3-introspect-pg) silently skip while CI stays green.', + ).toBe(true) + }, + ) + + it.runIf(IN_CI)( + 'CI must have PGRST_URL so the live supabase PostgREST suite does not silently skip', + () => { + expect( + LIVE_SUPABASE_PGREST_ENABLED, + 'CI must run the live supabase PostgREST suite — ' + + '`LIVE_SUPABASE_PGREST_ENABLED` is false. This needs a ' + + '`DATABASE_URL` AND a `PGRST_URL` pointing at the pinned ' + + '`postgrest/postgrest` service in .github/workflows/tests.yml (no ' + + 'CS_* creds — the domain CHECKs are structural). It is ' + + 'the ONLY suite that executes the adapter against a real PostgREST — ' + + 'the `prop:db_name::jsonb` aliasing selects, the `cs` containment ' + + 'mapping, and the full-envelope filter operands that every `public.*` ' + + 'domain CHECK must accept. Everything else asserts those as strings ' + + 'against a mock, so a false value here means the wire encoding is ' + + 'unproven while CI stays green.', + ).toBe(true) + }, + ) + + // Local dev with no creds: nothing to assert. Keep at least one always-run + // assertion so the file is never reported as fully empty/pending. + it('is always collected (guard file runs outside every live gate)', () => { + expect(typeof IN_CI).toBe('boolean') + }) +}) diff --git a/packages/stack/__tests__/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-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-client.test.ts b/packages/stack/__tests__/schema-v3-client.test.ts index b4838abdb..458039be6 100644 --- a/packages/stack/__tests__/schema-v3-client.test.ts +++ b/packages/stack/__tests__/schema-v3-client.test.ts @@ -23,18 +23,9 @@ const users = encryptedTable('schema_v3_client_users', { describeLive('eql_v3 client integration', () => { let protectClient: EncryptionClient - // INTERIM (CIP-3402): protect-ffi 0.27 has no v3 scalar query wire shape — - // scalar encryptQuery on the v3-wire client throws EQL_V3_QUERY_UNSUPPORTED. - // Query-term shape assertions run against a second, explicitly v2-wire client - // over the same schemas (index terms are identical across wire formats). - let termClient: EncryptionClient beforeAll(async () => { protectClient = await Encryption({ schemas: [users] }) - termClient = await Encryption({ - schemas: [users], - config: { eqlVersion: 2 }, - }) }) it('encrypts and decrypts a text_search column', async () => { @@ -47,13 +38,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 +52,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 +60,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 +76,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 +85,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 +104,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 +121,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 +130,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 +151,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 +164,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 +228,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/__tests__/schema-v3-pg.test.ts b/packages/stack/__tests__/schema-v3-pg.test.ts index a971cae94..fa6ed97f6 100644 --- a/packages/stack/__tests__/schema-v3-pg.test.ts +++ b/packages/stack/__tests__/schema-v3-pg.test.ts @@ -1,12 +1,12 @@ import 'dotenv/config' import postgres from 'postgres' -import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest' +import { afterAll, beforeAll, beforeEach, expect, it } from 'vitest' import type { EncryptionClient } from '@/encryption' import { encryptedTable, types } from '@/eql/v3' import { Encryption } from '@/index' import type { Encrypted } from '@/types' import { unwrapResult } from './fixtures' -import { assertV3WireEnvelope, installEqlV3IfNeeded } from './helpers/eql-v3' +import { installEqlV3IfNeeded } from './helpers/eql-v3' import { describeLivePg, LIVE_EQL_V3_PG_ENABLED } from './helpers/live-gate' const databaseUrl = process.env.DATABASE_URL @@ -35,36 +35,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 +66,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 ` @@ -103,17 +96,26 @@ 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({ + // `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,9 +124,9 @@ beforeAll(async () => { await sql` CREATE TABLE IF NOT EXISTS protect_ci_v3_typed_domains ( id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, - age eql_v3.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 ) ` @@ -158,7 +160,7 @@ afterAll(async () => { }, 30000) describeLivePg('eql_v3 text_search postgres integration', () => { - it('round-trips an encrypted value through an eql_v3.text_search column', async () => { + it('round-trips an encrypted value through an public.eql_v3_text_search column', async () => { const id = await insertRow('roundtrip', 'roundtrip@example.com') const [row] = await sql` @@ -171,15 +173,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 +192,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 @@ -257,14 +316,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 +361,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 +412,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 +428,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 +448,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.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..f044eeb72 100644 --- a/packages/stack/__tests__/schema-v3.test.ts +++ b/packages/stack/__tests__/schema-v3.test.ts @@ -11,76 +11,42 @@ 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', () => { + // 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() + const { ope: _v3Ord, ...v3Rest } = v3.indexes + const { ore: _v2Ord, ...v2Rest } = v2.indexes // toStrictEqual: byte-identical, no extra/undefined keys on either side. - expect(v3).toStrictEqual(v2) + expect({ ...v3, indexes: v3Rest }).toStrictEqual({ + ...v2, + indexes: v2Rest, + }) }) - 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, - include_original: false, + k: 6, + m: 2048, + include_original: true, }) }) - 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 +70,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 +99,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,12 +182,16 @@ 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' }], @@ -334,16 +322,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 +383,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 +415,26 @@ 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 +448,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-helpers.test.ts b/packages/stack/__tests__/supabase-helpers.test.ts new file mode 100644 index 000000000..bb5b870b8 --- /dev/null +++ b/packages/stack/__tests__/supabase-helpers.test.ts @@ -0,0 +1,585 @@ +import { describe, expect, it } from 'vitest' +import { + addJsonbCastsV3, + parseOrString, + rebuildOrString, +} from '@/supabase/helpers' +import type { DbPendingOrCondition } from '@/supabase/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/__tests__/supabase-introspect.test.ts b/packages/stack/__tests__/supabase-introspect.test.ts new file mode 100644 index 000000000..2fd9ccc52 --- /dev/null +++ b/packages/stack/__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 '@/supabase/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('@/supabase/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('@/supabase/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('@/supabase/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/__tests__/supabase-schema-builder.test.ts b/packages/stack/__tests__/supabase-schema-builder.test.ts new file mode 100644 index 000000000..27ce52180 --- /dev/null +++ b/packages/stack/__tests__/supabase-schema-builder.test.ts @@ -0,0 +1,244 @@ +import { describe, expect, it } from 'vitest' +import { encryptedTable, types } from '@/eql/v3' +import type { IntrospectionResult } from '@/supabase/introspect' +import { groupUnmodelledRows } from '@/supabase/introspect' +import { + mergeDeclaredTables, + synthesizeTables, +} from '@/supabase/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 `supabase-v3-introspect-pg.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/__tests__/supabase-v3-builder.test.ts b/packages/stack/__tests__/supabase-v3-builder.test.ts index 5fa9d8d02..e3fea4e5a 100644 --- a/packages/stack/__tests__/supabase-v3-builder.test.ts +++ b/packages/stack/__tests__/supabase-v3-builder.test.ts @@ -1,187 +1,15 @@ -import { describe, expect, it } from 'vitest' -import type { EncryptionClient } from '@/encryption' +import { describe, expect, it, vi } from 'vitest' 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 } -} +import { encryptedSupabase } from '@/supabase' +import { EncryptedQueryBuilderV3Impl } from '@/supabase/query-builder-v3' +import { + createMockEncryptionClient, + createMockSupabase, + fakeEnvelope, + isFakeEnvelope, + operation, +} from './helpers/supabase-mock' // --------------------------------------------------------------------------- // Schemas @@ -193,6 +21,9 @@ const users = encryptedTable('users', { 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', { @@ -200,27 +31,55 @@ const usersV2 = encryptedTableV2('users', { 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 -} - +// 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 es = encryptedSupabaseV3({ - encryptionClient: createMockEncryptionClient(), - supabaseClient: supabase.client, - }) - const from = () => es.from('users', users) - return { es, from, supabase } + 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') } // --------------------------------------------------------------------------- @@ -228,11 +87,45 @@ function v3Instance(resultData: unknown = []) { // --------------------------------------------------------------------------- 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 { from, supabase } = v3Instance() + const { es, supabase } = v3Instance() const createdAt = new Date('2026-01-02T03:04:05.000Z') - await from().insert({ email: 'a@b.com', createdAt, note: 'plain' }) + await es + .from('users', users) + .insert({ email: 'a@b.com', createdAt, note: 'plain' }) const [insert] = supabase.callsFor('insert') expect(insert).toBeDefined() @@ -248,9 +141,11 @@ describe('encryptedSupabaseV3 wire encoding', () => { }) it('bulk-inserts raw encrypted payloads keyed by DB column name', async () => { - const { from, supabase } = v3Instance() + const { es, supabase } = v3Instance() - await from().insert([{ email: 'a@b.com' }, { email: 'b@c.com' }]) + 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[] @@ -260,25 +155,25 @@ describe('encryptedSupabaseV3 wire encoding', () => { }) it('adds ::jsonb casts and aliases property names to DB names in select', async () => { - const { from, supabase } = v3Instance() + const { es, supabase } = v3Instance() - await from().select('id, email, createdAt') + 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 { from, supabase } = v3Instance() + const { es, supabase } = v3Instance() - await from().select('id, email').eq('email', 'a@b.com') + 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 eql_v3 domain CHECK when Postgres coerces it. + // 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() @@ -286,79 +181,132 @@ describe('encryptedSupabaseV3 wire encoding', () => { }) it('passes non-encrypted filters through untouched', async () => { - const { from, supabase } = v3Instance() + const { es, supabase } = v3Instance() - await from().select('id, email').eq('id', 42) + 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 { from, supabase } = v3Instance() + const { es, supabase } = v3Instance() - const lowerBound = new Date('2026-01-01T00:00:00.000Z') - await from().select('id, createdAt').gte('createdAt', lowerBound) + 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 like/ilike as PostgREST cs (bloom-filter containment)', async () => { - const { from, supabase } = v3Instance() + it('emits encrypted contains as PostgREST cs (bloom-filter containment)', async () => { + const { es, supabase } = v3Instance() - await from().select('id, email').like('email', 'a@b') - await from().select('id, email').ilike('email', 'a@b') + await es.from('users', users).select('id, email').contains('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) + 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 like/ilike on an encrypted column, naming contains', async () => { + const { es } = v3Instance() + + // The typed builder omits like/ilike, but an untyped JS caller reaches them. + expect(() => + es.from('users', users).select('id').like('email', '%a@b%'), + ).toThrow(/token containment.*Use contains\(\)/s) + expect(() => + es.from('users', users).select('id').ilike('email', '%a@b%'), + ).toThrow(/token containment.*Use contains\(\)/s) + }) + + 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 { from, supabase } = v3Instance() + const { es, supabase } = v3Instance() - await from().select('id, email').like('note', '%x%') + await es.from('users', users).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() + // `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(contains) on encrypted columns to not(cs)', async () => { + const { es, supabase } = v3Instance() - await from().select('id, email').not('email', 'like', 'a@b') + await es + .from('users', users) + .select('id, email') + .not('email', 'contains', 'a@b') const [not] = supabase.callsFor('not') expect(not.args[0]).toBe('email') expect(not.args[1]).toBe('cs') }) + // 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 { from, supabase } = v3Instance() + const { es, supabase } = v3Instance() - await from().select('id, nickname').in('nickname', ['ada', 'grace']) + await es + .from('users', users) + .select('id, nickname') + .in('nickname', ['ada', 'grace']) - const [inCall] = supabase.callsFor('in') + expect(supabase.callsFor('in')).toHaveLength(0) + const [inCall] = supabase.callsFor('filter') expect(inCall.args[0]).toBe('nickname') - const values = inCall.args[1] as string[] + 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(JSON.parse(values[0]).pt).toBe('ada') - expect(JSON.parse(values[1]).pt).toBe('grace') + expect(values[0].pt).toBe('ada') + expect(values[1].pt).toBe('grace') }) it('maps match() keys to DB names and encrypts values', async () => { - const { from, supabase } = v3Instance() + const { es, supabase } = v3Instance() - await from().select('id, nickname').match({ nickname: 'ada', id: 7 }) + 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 @@ -367,10 +315,11 @@ describe('encryptedSupabaseV3 wire encoding', () => { }) it('rejects a query type the column does not support', async () => { - const { from } = v3Instance() + const { es } = v3Instance() - // nickname is eql_v3.text_eq — equality only, no order/range - const { error, status } = await from() + // 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') @@ -379,10 +328,11 @@ describe('encryptedSupabaseV3 wire encoding', () => { }) it('rejects filters on storage-only columns', async () => { - const { from } = v3Instance() + const { es } = v3Instance() - // active is eql_v3.boolean — storage only - const { error, status } = await from() + // 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) @@ -391,6 +341,287 @@ describe('encryptedSupabaseV3 wire encoding', () => { 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('rejects order() on an ORE-capable encrypted column', async () => { + const { es } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id, createdAt') + .order('createdAt') + + expect(status).toBe(500) + expect(error?.message).toContain('cannot order by encrypted column') + expect(error?.message).toContain('created_at') + expect(error?.message).toContain('timestamp_ord') + expect(error?.message).toContain('ord_term') + }) + + it('rejects order() on an equality-only encrypted column', async () => { + const { es } = v3Instance() + + const { error, status } = await es + .from('users', users) + .select('id') + .order('amount') + + expect(status).toBe(500) + expect(error?.message).toContain('cannot order by encrypted column') + }) + + 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 = [ { @@ -402,9 +633,11 @@ describe('encryptedSupabaseV3 wire encoding', () => { ), }, ] - const { from } = v3Instance(rows) + const { es } = v3Instance(rows) - const { data, error } = await from().select('id, email, createdAt') + const { data, error } = await es + .from('users', users) + .select('id, email, createdAt') expect(error).toBeNull() expect(data).toHaveLength(1) @@ -415,94 +648,442 @@ describe('encryptedSupabaseV3 wire encoding', () => { ) }) - 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) + // `.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() - const { data, error } = await from().select('id, ts:createdAt') + await es.from('users', users).select('id').or('email.cs.ada') - // 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') + 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() + }) - // …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('gates an or() cs condition on the freeTextSearch capability', async () => { + const { es } = v3Instance() - it('rebuilds structured or() conditions with DB names, cs remap, and encrypted operands', async () => { - const { from, supabase } = 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') - 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 }, - ]) + expect(status).toBe(500) + expect(error?.message).toContain('does not support freeTextSearch') + }) - const [or] = supabase.callsFor('or') - const orString = or.args[0] as string + 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)') + }) - // 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('"{') + // 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 contains in a structured or() to cs', async () => { + const { es, supabase } = v3Instance() + + await es + .from('users', users) + .select('id') + .or([{ column: 'email', op: 'contains', 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$/, + ) + }) }) - it('rebuilds string-form or() with encrypted conditions remapped', async () => { - const { from, supabase } = v3Instance() + 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) + }) - await from().select('id, email').or('email.eq.a@b.com,id.eq.7') + // `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() - 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') + 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() + }) }) - it('passes a string-form or() through verbatim when no condition is encrypted', async () => { - const { from, supabase } = v3Instance() + // `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 }]) - await from().select('id').or('id.eq.7,note.eq.x') + const { data } = await es.from('users', users).select('id, createdAt') - const [or] = supabase.callsFor('or') - expect(or.args[0]).toBe('id.eq.7,note.eq.x') + 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', + ) + }) }) - it('rejects a null operand with a pointer to .is()', async () => { - const { from } = v3Instance() + // `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() - 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) + await es.from('users', users).select('id').not('email', 'contains', 'a@b') - expect(status).toBe(500) - expect(error?.message).toContain('null filter value') - expect(error?.message).toContain(".is('email', null)") + 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') + }) }) - it('still routes .is() null checks through untouched', async () => { - const { from, supabase } = v3Instance() + // `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 } + } - await from().select('id, email').is('email', null) + it('expands it as a real column in select(*)', async () => { + const { q, supabase } = protoInstance() - const [isCall] = supabase.callsFor('is') - expect(isCall.args).toEqual(['email', null]) + 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') + }) }) }) @@ -560,4 +1141,674 @@ describe('encryptedSupabase (v2) wire encoding is unchanged by the dialect seams 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) + }) + + 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)?/) + }) }) diff --git a/packages/stack/__tests__/supabase-v3-factory.test.ts b/packages/stack/__tests__/supabase-v3-factory.test.ts new file mode 100644 index 000000000..542a236f4 --- /dev/null +++ b/packages/stack/__tests__/supabase-v3-factory.test.ts @@ -0,0 +1,266 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { encryptedTable, types } from '@/eql/v3' +import type { SupabaseClientLike } from '@/supabase' +import { encryptedSupabaseV3 } from '@/supabase' +import type { IntrospectionData } from '@/supabase/introspect' +import { EncryptedQueryBuilderV3Impl } from '@/supabase/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('@/supabase/introspect', async (importActual) => { + const actual = await importActual() + return { ...actual, introspect: (url: string) => introspectMock(url) } +}) + +vi.mock('@/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/__tests__/supabase-v3-grants-pg.test.ts b/packages/stack/__tests__/supabase-v3-grants-pg.test.ts new file mode 100644 index 000000000..768f030c3 --- /dev/null +++ b/packages/stack/__tests__/supabase-v3-grants-pg.test.ts @@ -0,0 +1,179 @@ +/** + * 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 'dotenv/config' +import postgres from 'postgres' +import { afterAll, beforeAll, expect, it } from 'vitest' +import { + SUPABASE_PERMISSIONS_SQL_V3, + supabaseInternalPermissionsSql, +} from '../../cli/src/installer/grants' +import { installEqlV3IfNeeded } from './helpers/eql-v3' +import { describeLivePgOnly, LIVE_PG_ENABLED } from './helpers/live-gate' + +const databaseUrl = process.env.DATABASE_URL +const sql = LIVE_PG_ENABLED + ? postgres(databaseUrl as string, { prepare: false }) + : (undefined as unknown as postgres.Sql) + +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 () => { + if (!LIVE_PG_ENABLED) return + await installEqlV3IfNeeded(sql) + + // `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 () => { + if (!LIVE_PG_ENABLED) return + await sql.end() +}) + +describeLivePgOnly('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/__tests__/supabase-v3-introspect-pg.test.ts b/packages/stack/__tests__/supabase-v3-introspect-pg.test.ts new file mode 100644 index 000000000..e9390d3e1 --- /dev/null +++ b/packages/stack/__tests__/supabase-v3-introspect-pg.test.ts @@ -0,0 +1,137 @@ +import 'dotenv/config' +import postgres from 'postgres' +import { afterAll, beforeAll, expect, it } from 'vitest' +import { factoryForDomain } from '@/eql/v3/domain-registry' +import { introspect } from '@/supabase/introspect' +import { synthesizeTables } from '@/supabase/schema-builder' +import { installEqlV3IfNeeded } from './helpers/eql-v3' +import { describeLivePgOnly, LIVE_PG_ENABLED } from './helpers/live-gate' + +const databaseUrl = process.env.DATABASE_URL +const sql = LIVE_PG_ENABLED + ? postgres(databaseUrl as string, { prepare: false }) + : (undefined as unknown as postgres.Sql) + +const MODELLED = 'protect_ci_v3_introspect' +const UNMODELLED = 'protect_ci_v3_unmodelled' +const USER_DOMAIN = 'protect_ci_v3_user_json' + +beforeAll(async () => { + if (!LIVE_PG_ENABLED) return + await installEqlV3IfNeeded(sql) + 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`) + // Columns typed with EQL domains that have NO types factory. + 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 () => { + if (!LIVE_PG_ENABLED) return + 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) + +describeLivePgOnly('eql_v3 supabase introspection', () => { + it('detects EQL v3 domains and classifies plaintext columns', async () => { + const { tables } = await introspect(databaseUrl as string) + 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 as string) + + 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 as string) + + // Sanity: these really are EQL domains with no types factory. + expect(factoryForDomain('integer_ord_ope')).toBeUndefined() + expect(factoryForDomain('json')).toBeUndefined() + + const offenders = unmodelled.get(UNMODELLED) + expect(offenders).toBeDefined() + expect(offenders?.map((c) => c.columnName).sort()).toEqual(['doc', '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 as string) + 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 as string) + // `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. + it('synthesizeTables drops an unmodelled column but allColumns keeps it', async () => { + const { tables } = await introspect(databaseUrl as string) + const { tables: synth, allColumns } = synthesizeTables(tables) + + expect(Object.keys(synth.get(UNMODELLED)!.columnBuilders)).toEqual([]) + expect(allColumns.get(UNMODELLED)).toContain('score') + expect(allColumns.get(UNMODELLED)).toContain('doc') + }, 30000) +}) diff --git a/packages/stack/__tests__/supabase-v3-matrix.test.ts b/packages/stack/__tests__/supabase-v3-matrix.test.ts new file mode 100644 index 000000000..25170a309 --- /dev/null +++ b/packages/stack/__tests__/supabase-v3-matrix.test.ts @@ -0,0 +1,230 @@ +/** + * 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 { describe, expect, it } from 'vitest' +import type { AnyV3Table } from '@/eql/v3' +import { encryptedTable } from '@/eql/v3' +import { EncryptedQueryBuilderV3Impl } from '@/supabase/query-builder-v3' +import { + createMockEncryptionClient, + createMockSupabase, + isFakeEnvelope, +} from './helpers/supabase-mock' +import { + type DomainSpec, + type EqlV3TypeName, + eqlTypeSlug as slug, + typedEntries, + V3_MATRIX, +} from './v3-matrix/catalog' + +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 39 domains', () => { + expect(matrixEntries).toHaveLength(39) + expect(equalityDomains).toHaveLength(28) + expect(orderDomains).toHaveLength(19) + expect(matchDomains).toHaveLength(2) + expect(storageOnlyDomains).toHaveLength(10) + }) + + 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() + }) + + // `gte` works — the `>=` operators ARE declared on the ord domains — but + // `order()` does not: no btree OPERATOR CLASS exists on any domain, so + // `ORDER BY col` falls through to jsonb's default opclass and sorts the + // ciphertext envelope. Filtering and sorting resolve through different + // machinery, and only sorting is broken. + 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('ord_term') + expect(supabase.callsFor('order')).toHaveLength(0) + }) + }) + + describe.each(matchDomains)('%s (freeTextSearch)', (eqlType, spec) => { + it('emits contains() as a cs containment filter', async () => { + const { q, supabase, name } = instanceFor(eqlType, spec) + + await q.select(`id, ${name}`).contains(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 like(), directing the caller to contains()', async () => { + const { q, name } = instanceFor(eqlType, spec) + + expect(() => q.like(name, firstSample(spec) as string)).toThrow( + /Use contains\(\)/, + ) + }) + }) + + 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/__tests__/supabase-v3-pgrest-live.test.ts b/packages/stack/__tests__/supabase-v3-pgrest-live.test.ts new file mode 100644 index 000000000..cbaf6470e --- /dev/null +++ b/packages/stack/__tests__/supabase-v3-pgrest-live.test.ts @@ -0,0 +1,524 @@ +/** + * 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 'dotenv/config' +import postgres from 'postgres' +import { afterAll, beforeAll, expect, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { encryptedTable, types } from '@/eql/v3' +import { EncryptedQueryBuilderV3Impl } from '@/supabase/query-builder-v3' +import { SUPABASE_PERMISSIONS_SQL_V3 } from '../../cli/src/installer/grants' +import { installEqlV3IfNeeded } from './helpers/eql-v3' +import { + describeLiveSupabasePgrest, + LIVE_SUPABASE_PGREST_ENABLED, +} from './helpers/live-gate' +import { makePostgrestClient, reloadSchemaCache } from './helpers/pgrest' +import { narrowedQueryTerm, storageEnvelope } from './helpers/v3-envelope' + +const TABLE = 'protect_ci_v3_pgrest' + +const sql = LIVE_SUPABASE_PGREST_ENABLED + ? postgres(process.env.DATABASE_URL as string, { prepare: false }) + : (undefined as unknown as postgres.Sql) + +// 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 3-gram token set, plus the whole value as one extra token — + * emulating the default `include_original: true`. That is precisely why a + * SUBSTRING `like` does not match: the pattern's bloom carries the whole + * pattern as a token the stored value's bloom lacks (see the class doc on + * `query-builder-v3.ts`). */ +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 = [hash(lower)] // include_original + 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 () => { + if (!LIVE_SUPABASE_PGREST_ENABLED) return + await installEqlV3IfNeeded(sql) + + // The shipped Supabase grants — the thing under test, not a hand-rolled + // approximation. Re-applied after install because the bundle DROPs eql_v3. + await sql.unsafe(SUPABASE_PERMISSIONS_SQL_V3) + 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 () => { + if (!LIVE_SUPABASE_PGREST_ENABLED) return + await sql.unsafe(`DROP TABLE IF EXISTS ${TABLE}`) + await sql.end() +}) + +describeLiveSupabasePgrest('supabase v3 adapter over real PostgREST', () => { + 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 three tests below discriminate: a + // 3-char needle matches while a 7-char one does not, and neither shares the + // stored `c`. Only bloom containment explains that. + // + // With the default `include_original: true` the needle's bloom carries the + // WHOLE needle as an extra token, so only an exact-value needle matches. + // Asserts the DOCUMENTED semantics, not the intuitive ones. + it('resolves contains() through cs containment for an exact value', async () => { + const { data, error } = await from() + .select('row_key') + .contains('email', 'ada@example.com') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // A needle LONGER than the tokenizer's 3-gram window contributes an + // `include_original` token no stored trigram can supply, so containment + // fails. (A needle of exactly 3 characters is the degenerate case: its + // whole-value token IS a trigram, so `contains('email','ada')` DOES match.) + // This is the KNOWN-BROKEN substring defect, shared with v3 Drizzle's + // `contains` and tracked upstream in EQL. Pinned so a fix is a visible change. + it('does not match a longer substring under include_original', async () => { + const { data, error } = await from() + .select('row_key') + .contains('email', 'example') + + expect(error).toBeNull() + expect(data).toEqual([]) + }) + + it('matches a 3-character substring, the degenerate include_original case', async () => { + const { data, error } = await from() + .select('row_key') + .contains('email', 'ada') + + expect(error).toBeNull() + expect(data.map((r: { row_key: string }) => r.row_key)).toEqual(['ada']) + }) + + // The reason `like` is gone: `~~` is not defined on public.eql_v3_text_search, so + // had the adapter emitted it, PostgREST/Postgres would answer 42883. The + // client-side guard turns that into an actionable error before the round-trip. + it('refuses like() on an encrypted column rather than emitting an undefined operator', async () => { + expect(() => from().select('row_key').like('email', 'ada')).toThrow( + /Use contains\(\)/, + ) + }) + + // 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([]) + }) + + 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/__tests__/supabase-v3-select-star.test.ts b/packages/stack/__tests__/supabase-v3-select-star.test.ts new file mode 100644 index 000000000..3e1b3522d --- /dev/null +++ b/packages/stack/__tests__/supabase-v3-select-star.test.ts @@ -0,0 +1,195 @@ +import { describe, expect, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { encryptedTable, types } from '@/eql/v3' +import { EncryptedQueryBuilderV3Impl } from '@/supabase/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/__tests__/supabase-v3-wire.test.ts b/packages/stack/__tests__/supabase-v3-wire.test.ts new file mode 100644 index 000000000..f9f0716db --- /dev/null +++ b/packages/stack/__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 { describe, expect, it } from 'vitest' +import { encryptedTable, types } from '@/eql/v3' +import { EncryptedQueryBuilderV3Impl } from '@/supabase/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/__tests__/supabase-v3.test-d.ts b/packages/stack/__tests__/supabase-v3.test-d.ts index 2c709f082..8b042f237 100644 --- a/packages/stack/__tests__/supabase-v3.test-d.ts +++ b/packages/stack/__tests__/supabase-v3.test-d.ts @@ -1,16 +1,14 @@ import { describe, expectTypeOf, it } from 'vitest' -import type { EncryptionClient } from '@/encryption' -import { encryptedTable, types } from '@/eql/v3' +import { encryptedTable, type InferPlaintext, types } from '@/eql/v3' import { encryptedColumn, encryptedTable as v2EncryptedTable } from '@/schema' import { - type EncryptedQueryBuilder, + type EncryptedQueryBuilderV3, type EncryptedSupabaseResponse, encryptedSupabase, encryptedSupabaseV3, type SupabaseClientLike, } from '@/supabase' -declare const encryptionClient: EncryptionClient declare const supabaseClient: SupabaseClientLike const users = encryptedTable('users', { @@ -18,118 +16,312 @@ const users = encryptedTable('users', { amount: types.IntegerOrd('amount'), createdAt: types.TimestampOrd('created_at'), active: types.Boolean('active'), + nickname: types.TextEq('nickname'), + bio: types.TextMatch('bio'), }) -type UserRow = { - id: number - email: string - amount: number - createdAt: Date - active: boolean - note: string -} +type UserRow = InferPlaintext -const es = encryptedSupabaseV3({ encryptionClient, supabaseClient }) +/** + * 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 } +> -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') +/** 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' - // Schema columns carry their domain plaintext types +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('narrows filter keys in the DEFAULT-Row case (no index-signature widening)', () => { - const builder = es.from('users', users) - + 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') + }) - // 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 + 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) + }) - // 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) + // 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) }) - it('pins filter value types to the column plaintext with an explicit row type', () => { - const builder = es.from('users', users) + // `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) + }) - builder.eq('email', 'a@b.com') - builder.gte('amount', 10) - builder.gte('createdAt', new Date()) - builder.eq('id', 1) + it('rejects order() on every encrypted column at the type level', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, + }) + const builder = supabase.from('users') + // No btree opclass exists on any EQL v3 domain, so `ORDER BY col` sorts the + // ciphertext envelope. This holds for the ORE-capable domains too — which is + // the whole point: those are the ones where the wrongness is silent. + // @ts-expect-error — timestamp_ord: ORDER BY sorts ciphertext + builder.order('createdAt') + // @ts-expect-error — integer_ord: ORDER BY sorts ciphertext + builder.order('amount', { ascending: false }) + // @ts-expect-error — active is public.eql_v3_boolean: storage only + builder.order('active') + }) - // 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('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('rejects filters on storage-only columns at the type level', () => { - const builder = es.from('users', users) + it('narrows contains() 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.contains('email', 'ada') + // public.eql_v3_text_match — freeTextSearch only + builder.contains('bio', 'ada') + // @ts-expect-error — nickname is public.eql_v3_text_eq: no match index + builder.contains('nickname', 'ada') + // @ts-expect-error — amount is public.eql_v3_integer_ord: no match index + builder.contains('amount', 'ada') + // @ts-expect-error — active is public.eql_v3_boolean (storage only) + builder.contains('active', 'ada') + }) - // 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 }) + // `V3FreeTextSearchableKeys` deliberately admits plaintext row keys so that + // `contains()` reaches PostgREST's NATIVE jsonb/array containment — which the + // runtime already does, forwarding a non-encrypted operand straight to + // `q.contains`. A blanket `value: string` made that unreachable from + // TypeScript: the operand type must follow the column. + it('accepts native containment operands on a plaintext key', () => { + mixedBuilder.contains('tags', ['vip']) + mixedBuilder.contains('meta', { plan: 'pro' }) + mixedBuilder.contains('tags', 'vip') }) - it('accepts plaintext model values on insert', () => { - const builder = es.from('users', users) + it('still pins an encrypted text-search operand to string', () => { + mixedBuilder.contains('email', 'ada') + // @ts-expect-error — email is public.eql_v3_text_search: the match term is a string + mixedBuilder.contains('email', ['ada']) + // @ts-expect-error — bio is public.eql_v3_text_match: the match term is a string + mixedBuilder.contains('bio', { a: 1 }) + }) - builder.insert({ email: 'a@b.com', amount: 3, createdAt: new Date() }) - builder.insert([{ email: 'a@b.com' }, { note: 'plain' }]) + // A union column key is only as permissive as its STRICTEST member. If any + // member is a declared encrypted column the operand must be the string term: + // that member's runtime path hands the operand to `encrypt()`, which has no + // plaintext-type guard, so an array reaches protect-ffi as the plaintext for a + // `cast_as: text` column. + it('pins a mixed union key to the encrypted string operand', () => { + mixedBuilder.contains(mixedKey, 'ada') + // @ts-expect-error — the union includes email (public.eql_v3_text_search) + mixedBuilder.contains(mixedKey, ['vip']) + // @ts-expect-error — the union includes email (public.eql_v3_text_search) + mixedBuilder.contains(mixedKey, { plan: 'pro' }) + }) + + it('leaves a union of plaintext keys on the native operand', () => { + mixedBuilder.contains(plaintextKey, ['vip']) + mixedBuilder.contains(plaintextKey, { plan: 'pro' }) + }) + + // `@>` is defined on arrays and jsonb, not on a scalar. Postgres answers a + // containment query against a plaintext `text` column with 42883 + // (operator does not exist), so the operand type must follow the column's own + // shape rather than admitting every native containment value on every + // plaintext key. + it('rejects containment 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 containment 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 contains() + builder.like('email', '%ada%') + // @ts-expect-error — v3 free-text search is token containment: use contains() + builder.ilike('email', '%ada%') + // The chain must not launder the removal back in via a widened return type. + // @ts-expect-error — use contains() + builder.select('id').eq('email', 'a@b.com').like('email', '%ada%') + // contains() survives the chain. + builder.select('id').eq('email', 'a@b.com').contains('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', () => { - const builder = es.from('users', users) - expectTypeOf(builder.select('id, email')).resolves.toEqualTypeOf< - EncryptedSupabaseResponse - >() + 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('rejects a v2 schema', () => { - const v2Table = v2EncryptedTable('users', { - email: encryptedColumn('email').equality(), + it('keeps undeclared tables reachable on the untyped surface (the gradient)', async () => { + const supabase = await encryptedSupabaseV3(supabaseClient, { + schemas: { users }, }) - - // @ts-expect-error — encryptedSupabaseV3 only accepts v3 tables - es.from('users', v2Table) + // `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>() }) -}) -describe('encryptedSupabase (v2) typing is unchanged', () => { - it('keeps the single-generic builder shape', () => { - const esV2 = encryptedSupabase({ encryptionClient, supabaseClient }) + 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 }, + }) + }) +}) - type V2Row = { id: number; email: string } - const builder = esV2.from('users', v2Table) - expectTypeOf(builder).toEqualTypeOf>() +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 contains and not like/ilike, exactly as the typed surface does', async () => { + // Without `schemas` there is no capability information, so `contains` cannot + // 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. + const supabase = await encryptedSupabaseV3(supabaseClient) + const builder = supabase.from<{ id: number; email: string }>('users') + builder.contains('email', 'ada') + // @ts-expect-error — v3 free-text search is token containment: use contains() + builder.like('email', '%ada%') + // @ts-expect-error — v3 free-text search is token containment: use contains() + 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/__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__/supabase-verify.test.ts b/packages/stack/__tests__/supabase-verify.test.ts new file mode 100644 index 000000000..4762c7ed5 --- /dev/null +++ b/packages/stack/__tests__/supabase-verify.test.ts @@ -0,0 +1,88 @@ +import { describe, expect, it } from 'vitest' +import { encryptedTable, types } from '@/eql/v3' +import type { IntrospectionResult } from '@/supabase/introspect' +import { verifyDeclaredSchemas } from '@/supabase/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__/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..896375595 100644 --- a/packages/stack/__tests__/v3-matrix/catalog.ts +++ b/packages/stack/__tests__/v3-matrix/catalog.ts @@ -23,23 +23,19 @@ import type { QueryCapabilities, } from '@/eql/v3' import { + EncryptedBigintColumn, + EncryptedBigintEqColumn, + EncryptedBigintOrdColumn, + EncryptedBigintOrdOreColumn, EncryptedBooleanColumn, EncryptedDateColumn, EncryptedDateEqColumn, EncryptedDateOrdColumn, EncryptedDateOrdOreColumn, - EncryptedRealColumn, - EncryptedRealEqColumn, - EncryptedRealOrdColumn, - EncryptedRealOrdOreColumn, EncryptedDoubleColumn, EncryptedDoubleEqColumn, EncryptedDoubleOrdColumn, EncryptedDoubleOrdOreColumn, - EncryptedSmallintColumn, - EncryptedSmallintEqColumn, - EncryptedSmallintOrdColumn, - EncryptedSmallintOrdOreColumn, EncryptedIntegerColumn, EncryptedIntegerEqColumn, EncryptedIntegerOrdColumn, @@ -48,6 +44,14 @@ import { EncryptedNumericEqColumn, EncryptedNumericOrdColumn, EncryptedNumericOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, EncryptedTextColumn, EncryptedTextEqColumn, EncryptedTextMatchColumn, @@ -99,12 +103,14 @@ export type DomainSpec = Readonly<{ * 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 + samples: ReadonlyArray /** * Values that MUST fail encryption. Number domains reject `NaN`/`±Infinity` - * via a global guard; other domains omit this. + * 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 + errorSamples?: ReadonlyArray }> /** @@ -117,6 +123,20 @@ export function typedEntries( 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, @@ -151,11 +171,17 @@ const FULL = { 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 -// `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: {} } +// 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' }], @@ -166,7 +192,7 @@ const MATCH_BLOCK: NonNullable['match'] = { const MATCH_IDX: Indexes = { match: MATCH_BLOCK } const TEXT_SEARCH_IDX: Indexes = { unique: { token_filters: [] }, - ore: {}, + ope: {}, match: MATCH_BLOCK, } @@ -175,81 +201,103 @@ const TEXT_SEARCH_IDX: Indexes = { // 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 -// 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', +// 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', - 'Ada Lovelace', + '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. 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 }, + '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 }, + 'public.eql_v3_integer_ord': { builder: types.IntegerOrd, ColumnClass: EncryptedIntegerOrdColumn, castAs: 'number', capabilities: ORD, indexes: OPE_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 }, + '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 }, + '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 }, + 'public.eql_v3_bigint_ord': { builder: types.BigintOrd, ColumnClass: EncryptedBigintOrdColumn, castAs: 'bigint', capabilities: ORD, indexes: OPE_IDX, samples: BIGINT_S, errorSamples: BIGINT_ERR }, // date - 'eql_v3.date': { builder: types.Date, ColumnClass: EncryptedDateColumn, castAs: 'date', capabilities: STORAGE, indexes: NONE, samples: DATE_S }, - 'eql_v3.date_eq': { builder: types.DateEq, ColumnClass: EncryptedDateEqColumn, castAs: 'date', capabilities: EQ, indexes: UNIQUE_IDX, samples: DATE_S }, - 'eql_v3.date_ord_ore': { builder: types.DateOrdOre, ColumnClass: EncryptedDateOrdOreColumn, castAs: 'date', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, - 'eql_v3.date_ord': { builder: types.DateOrd, ColumnClass: EncryptedDateOrdColumn, castAs: 'date', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, + 'public.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 }, + 'public.eql_v3_date_ord': { builder: types.DateOrd, ColumnClass: EncryptedDateOrdColumn, castAs: 'date', capabilities: ORD, indexes: OPE_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 }, + '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 }, + 'public.eql_v3_timestamp_ord': { builder: types.TimestampOrd, ColumnClass: EncryptedTimestampOrdColumn, castAs: 'timestamp', capabilities: ORD, indexes: OPE_IDX, samples: TS_S }, // numeric - 'eql_v3.numeric': { builder: types.Numeric, ColumnClass: EncryptedNumericColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: NUMERIC_S, errorSamples: NUM_ERR }, - 'eql_v3.numeric_eq': { builder: types.NumericEq, ColumnClass: EncryptedNumericEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, - 'eql_v3.numeric_ord_ore': { builder: types.NumericOrdOre, ColumnClass: EncryptedNumericOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, - 'eql_v3.numeric_ord': { builder: types.NumericOrd, ColumnClass: EncryptedNumericOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, + 'public.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 }, + 'public.eql_v3_numeric_ord': { builder: types.NumericOrd, ColumnClass: EncryptedNumericOrdColumn, castAs: 'number', capabilities: ORD, indexes: OPE_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 }, + '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 }, + '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 - 'eql_v3.boolean': { builder: types.Boolean, ColumnClass: EncryptedBooleanColumn, castAs: 'boolean', capabilities: STORAGE, indexes: NONE, samples: BOOLEAN_S }, + 'public.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 }, + '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 }, + 'public.eql_v3_real_ord': { builder: types.RealOrd, ColumnClass: EncryptedRealOrdColumn, castAs: 'number', capabilities: ORD, indexes: OPE_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 }, + '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 }, + 'public.eql_v3_double_ord': { builder: types.DoubleOrd, ColumnClass: EncryptedDoubleOrdColumn, castAs: 'number', capabilities: ORD, indexes: OPE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, } as const satisfies Record diff --git a/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts b/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts index bd1343bfa..3d9ad5c68 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts +++ b/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts @@ -14,33 +14,57 @@ * 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`), + * ONE mega table (all 39 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. + * 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 `integer_ord`: a valid, unique Postgres column name. */ -const slug = (t: EqlV3TypeName): string => t.replace('eql_v3.', '') +const expectDecryptedStorageValue = ( + decrypted: unknown, + expected: unknown, +): void => { + if (expected instanceof Date) { + expect(typeof decrypted).toBe('string') + expect(new Date(decrypted)).toEqual(expected) + return + } + + expect(decrypted).toBe(expected) +} const domains = typedEntries(V3_MATRIX) @@ -73,66 +107,142 @@ const columns = Object.fromEntries( 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. + * 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`. */ -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 hasIndex = ( + indexes: DomainSpec['indexes'], + key: 'unique' | 'ore' | 'ope' | 'match', +): boolean => Boolean(indexes?.[key]) -const matchDomains = domains.filter( - ([, spec]) => proofKindFor(spec.indexes) === 'match', +/** 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]) => proofKindFor(spec.indexes) === 'eq', + ([, spec]) => + hasIndex(spec.indexes, 'unique') && !hasIndex(spec.indexes, 'match'), ) const ordDomains = domains.filter( - ([, spec]) => proofKindFor(spec.indexes) === 'ord', + ([, spec]) => hasOrdering(spec.indexes) && !hasIndex(spec.indexes, 'match'), ) const storageDomains = domains.filter( - ([, spec]) => proofKindFor(spec.indexes) === 'storage', + ([, 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 termClient: 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 () => { 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 ') + // 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, @@ -141,27 +251,31 @@ beforeAll(async () => { ) `) - // Two model rows: row A carries samples[0], row B carries samples[1], for - // every domain — every catalog `samples` array has at least two entries. - const rowA: Record = {} - const rowB: Record = {} - for (const [t, spec] of domains) { - rowA[slug(t)] = spec.samples[0] - rowB[slug(t)] = spec.samples[1] - } + // Model rows for the ordering proofs: row i carries `samples[min(i, L-1)]` + // for every domain (`L` = that domain's sample count). Rows 0/1 double as the + // classic two-row seed (samples[0]/samples[1]) reused by the existing proofs; + // rows 2..MAX_ORDER_ROWS-1 give the extra distinct values numeric/text + // ordering domains need for a full a { + const row: Record = {} + for (const [t, spec] of domains) { + row[slug(t)] = spec.samples[Math.min(i, spec.samples.length - 1)] + } + return row + }) - const [encA, encB] = unwrapResult( - await client.bulkEncryptModels([rowA, rowB] as never, table as never), + const encModels = unwrapResult( + await client.bulkEncryptModels(models as never, table as never), ) as Array> - // 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 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 — @@ -173,109 +287,323 @@ beforeAll(async () => { `INSERT INTO ${TABLE_NAME} (test_run_id, ${colNames.join(', ')}) VALUES ($1, ${casts.join(', ')}) RETURNING id`, - [TEST_RUN_ID, ...values], + [runId, ...values], ) return row.id } - idA = await insertRow(encA) - idB = await insertRow(encB) + idA = await insertRow(encModels[0], TEST_RUN_ID) + idB = await insertRow(encModels[1], TEST_RUN_ID) + orderIds = [] + for (const enc of encModels) { + orderIds.push(await insertRow(enc, ORDER_RUN_ID)) + } const columnRef = (t: EqlV3TypeName) => (table as unknown as Record)[slug(t)] as never - // The full `opts` object (not just `column`) is cast `as never`: `encryptQuery` - // derives its allowed `queryType` union FROM the column's type - // (`QueryTypesForColumn`), so a `never`-typed `column` alone collapses - // `queryType` to `undefined` rather than widening it — this table's columns - // are built dynamically (`Object.fromEntries`), so none of them carry a - // statically-known type for `encryptQuery` to key off in the first place. - for (const [t, spec] of eqDomains) { - eqTerms[slug(t)] = unwrapResult( - await termClient.encryptQuery( - spec.samples[0] 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), - queryType: 'equality', } 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)] = unwrapResult( - await termClient.encryptQuery( - spec.samples[0] as never, - { - table, - column: columnRef(t), - queryType: 'equality', - } as never, - ), - ) + ordTerms[slug(t)] = await encryptOperand(t, spec.samples[0]) } - // 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. + // text_match/text_search: query the substring "ada", present only in the + // seeded sample of exactly one row per domain. for (const [t] of matchDomains) { - matchTerms[slug(t)] = unwrapResult( - await termClient.encryptQuery( - 'ada' as never, - { - table, - column: columnRef(t), - queryType: 'freeTextSearch', - } as never, - ), - ) + 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 () => { if (!LIVE_EQL_V3_PG_ENABLED) return - await sql.unsafe(`DELETE FROM ${TABLE_NAME} WHERE test_run_id = $1`, [ - TEST_RUN_ID, + await sql.unsafe(`DELETE FROM ${TABLE_NAME} WHERE test_run_id = ANY($1)`, [ + [TEST_RUN_ID, ORDER_RUN_ID], ]) await sql.end() }, 30000) -describeLivePg('v3 matrix live Postgres coverage (all 35 domains)', () => { +describeLivePg('v3 matrix live Postgres coverage (all 39 domains)', () => { it.each( eqDomains, - )('%s: eq_term/hmac_256 selects the exact row', async (eqlType) => { + )('%s: eql_v3.eq(col, operand) selects the exact row', async (eqlType) => { const col = slug(eqlType) const rows = await sql.unsafe( `SELECT id FROM ${TABLE_NAME} WHERE test_run_id = $1 - AND eql_v3.eq_term("${col}") = eql_v3_internal.hmac_256($2::jsonb)`, + AND eql_v3.eq("${col}", $2::jsonb)`, [TEST_RUN_ID, sql.json(eqTerms[col] as never)], ) expect(rows.map((r) => r.id)).toEqual([idA]) }) + 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: ord_term/ore_block_256 equality-via-ORE selects the exact row', async (eqlType) => { + )('%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 eql_v3.ord_term("${col}") = eql_v3_internal.ore_block_256($2::jsonb)`, + 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: match_term/bloom_filter selects row B (containing "ada"), not row A', async (eqlType) => { + )('%s: eql_v3.contains selects the row containing "ada"', async (eqlType, spec) => { const col = slug(eqlType) + const expectedId = String(spec.samples[0]).includes('ada') ? idA : idB const rows = await sql.unsafe( `SELECT id FROM ${TABLE_NAME} WHERE test_run_id = $1 - AND eql_v3.match_term("${col}") @> eql_v3_internal.bloom_filter($2::jsonb)`, + AND eql_v3.contains("${col}", $2::jsonb)`, [TEST_RUN_ID, sql.json(matchTerms[col] as never)], ) - expect(rows.map((r) => r.id)).toEqual([idB]) + 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( @@ -288,14 +616,6 @@ describeLivePg('v3 matrix live Postgres coverage (all 35 domains)', () => { ) 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) - } + expectDecryptedStorageValue(decrypted, expected) }) }) diff --git a/packages/stack/__tests__/v3-matrix/matrix-live.test.ts b/packages/stack/__tests__/v3-matrix/matrix-live.test.ts index ff51f02f7..ba08e2656 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-live.test.ts +++ b/packages/stack/__tests__/v3-matrix/matrix-live.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 @@ -18,26 +18,24 @@ * client-side before any network — and so stay cheap even one at a time. */ import 'dotenv/config' -import { beforeAll, describe, expect, it } from 'vitest' +import { beforeAll, expect, it } from 'vitest' import { EncryptionV3, encryptedTable } from '@/encryption/v3' import { unwrapResult } from '../fixtures' -import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' +import { describeLive } from '../helpers/live-gate' import { type DomainSpec, type EqlV3TypeName, + eqlTypeSlug as slug, typedEntries, V3_MATRIX, } from './catalog' -/** `eql_v3.integer_ord` → `integer_ord`: a valid, per-domain-unique column name. */ -const slug = (t: EqlV3TypeName): string => t.replace('eql_v3.', '') - // `as const satisfies Record<...>` gives `V3_MATRIX` a narrower type than // `Record` (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). @@ -104,9 +102,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.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..21b2a6e6f --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/needle-for.test.ts @@ -0,0 +1,55 @@ +import { describe, expect, it } from 'vitest' +import { matchNeedleError } from '@/schema/match-defaults' +import { V3_MATRIX } from './catalog' +import { needleFor } from './needle-for' + +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__/v3-matrix/needle-for.ts b/packages/stack/__tests__/v3-matrix/needle-for.ts new file mode 100644 index 000000000..cfde47563 --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/needle-for.ts @@ -0,0 +1,26 @@ +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 `contains` + * 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 = 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/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/package.json b/packages/stack/package.json index 51ab9b44b..c476443cd 100644 --- a/packages/stack/package.json +++ b/packages/stack/package.json @@ -54,6 +54,9 @@ "eql/v3": [ "./dist/eql/v3/index.d.ts" ], + "eql/v3/drizzle": [ + "./dist/eql/v3/drizzle/index.d.ts" + ], "v3": [ "./dist/encryption/v3.d.ts" ], @@ -125,6 +128,16 @@ "default": "./dist/eql/v3/index.cjs" } }, + "./eql/v3/drizzle": { + "import": { + "types": "./dist/eql/v3/drizzle/index.d.ts", + "default": "./dist/eql/v3/drizzle/index.js" + }, + "require": { + "types": "./dist/eql/v3/drizzle/index.d.cts", + "default": "./dist/eql/v3/drizzle/index.cjs" + } + }, "./v3": { "import": { "types": "./dist/encryption/v3.d.ts", @@ -207,21 +220,26 @@ "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" }, "devDependencies": { + "@cipherstash/eql": "3.0.0", "@clack/prompts": "^1.4.0", + "@supabase/postgrest-js": "2.105.4", "@supabase/supabase-js": "^2.105.4", + "@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 +252,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" @@ -250,7 +268,8 @@ }, "peerDependencies": { "@supabase/supabase-js": ">=2", - "drizzle-orm": ">=0.33" + "drizzle-orm": ">=0.33", + "pg": ">=8" }, "peerDependenciesMeta": { "drizzle-orm": { @@ -258,6 +277,9 @@ }, "@supabase/supabase-js": { "optional": true + }, + "pg": { + "optional": true } }, "engines": { 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/drizzle/operators.ts b/packages/stack/src/drizzle/operators.ts index 0644d7de3..c31e2ff07 100644 --- a/packages/stack/src/drizzle/operators.ts +++ b/packages/stack/src/drizzle/operators.ts @@ -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/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..acf4b1b82 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, @@ -127,8 +128,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 +140,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,8 +172,38 @@ 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', + }, + } + return { encrypt: (plaintext, opts) => client.encrypt(plaintext as never, opts as never), @@ -182,16 +215,19 @@ export function typedClient( 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 +245,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 +265,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..823bc5d2e 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,7 +8,7 @@ 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`). */ export type QueryCapabilities = Readonly<{ @@ -21,9 +17,25 @@ export type QueryCapabilities = Readonly<{ freeTextSearch: 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' | DateLikeCast /** * The full, literal definition of a v3 domain. This is the LOAD-BEARING type: @@ -34,7 +46,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 }> @@ -84,7 +96,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 +106,240 @@ 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. */ 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,7 +348,7 @@ function indexesForCapabilities( } if (capabilities.orderAndRange) { - indexes.ore = {} + indexes[ordering] = {} } if (capabilities.freeTextSearch) { @@ -326,6 +360,15 @@ function indexesForCapabilities( 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 ( @@ -377,6 +420,7 @@ export class EncryptedV3Column { indexes: indexesForCapabilities( this.definition.capabilities, this.definition.castAs, + orderingForEqlType(this.definition.eqlType), ), } } @@ -389,15 +433,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 +456,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 +497,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 {} @@ -585,6 +597,10 @@ export type AnyEncryptedV3Column = | EncryptedSmallintEqColumn | EncryptedSmallintOrdOreColumn | EncryptedSmallintOrdColumn + | EncryptedBigintColumn + | EncryptedBigintEqColumn + | EncryptedBigintOrdOreColumn + | EncryptedBigintOrdColumn | EncryptedDateColumn | EncryptedDateEqColumn | EncryptedDateOrdOreColumn @@ -613,6 +629,15 @@ export type AnyEncryptedV3Column = | EncryptedDoubleOrdOreColumn | EncryptedDoubleOrdColumn +/** + * 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. * (Nested fields are deferred to later increments.) @@ -626,11 +651,13 @@ 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 + : 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/drizzle/codec.ts b/packages/stack/src/eql/v3/drizzle/codec.ts new file mode 100644 index 000000000..0db6f55b8 --- /dev/null +++ b/packages/stack/src/eql/v3/drizzle/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 '@/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/src/eql/v3/drizzle/column.ts b/packages/stack/src/eql/v3/drizzle/column.ts new file mode 100644 index 000000000..abc2be4c2 --- /dev/null +++ b/packages/stack/src/eql/v3/drizzle/column.ts @@ -0,0 +1,121 @@ +import { customType } from 'drizzle-orm/pg-core' +import { type AnyEncryptedV3Column, types as v3Types } from '@/eql/v3' +import type { Encrypted } from '@/types' +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/src/eql/v3/drizzle/index.ts b/packages/stack/src/eql/v3/drizzle/index.ts new file mode 100644 index 000000000..7c0426d4c --- /dev/null +++ b/packages/stack/src/eql/v3/drizzle/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/src/eql/v3/drizzle/operators.ts b/packages/stack/src/eql/v3/drizzle/operators.ts new file mode 100644 index 000000000..251f4e4b3 --- /dev/null +++ b/packages/stack/src/eql/v3/drizzle/operators.ts @@ -0,0 +1,558 @@ +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 type { AuditConfig } from '@/encryption/operations/base-operation' +import type { AnyEncryptedV3Column, AnyV3Table } from '@/eql/v3' +import type { LockContext } from '@/identity' +import type { ColumnSchema } from '@/schema' +import { matchNeedleError } from '@/schema/match-defaults' +import { getEqlV3Column } from './column.js' +import { + extractEncryptionSchemaV3, + getDrizzleTableName, +} from './schema-extraction.js' +import { type ComparisonOp, type EqualityOp, v3Dialect } from './sql-dialect.js' + +const MAX_IN_ARRAY_CONCURRENCY = 4 + +/** + * The client capabilities this factory consumes: `encrypt`, and `bulkEncrypt` + * when the client offers it. 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. The + * factory resolves the column/table at runtime and encrypts through its own + * casts, so it relies on none of the client's per-column `encrypt` overloads. + * + * `bulkEncrypt` is optional so a `{ encrypt }`-only client stays valid; the + * list operators fall back to bounded-concurrency single encryption without it. + */ +type OperandEncryptionClient = { + encrypt( + plaintext: never, + opts: { table: AnyV3Table; column: AnyEncryptedV3Column }, + ): unknown + bulkEncrypt?( + plaintexts: never, + opts: { table: AnyV3Table; column: AnyEncryptedV3Column }, + ): unknown +} + +/** + * 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 +} + +export type EncryptionOperatorCallOpts = { + lockContext?: LockContext + audit?: AuditConfig +} + +type ChainableOperation = { + withLockContext(lockContext: LockContext): ChainableOperation + audit(config: AuditConfig): ChainableOperation + then: PromiseLike<{ + data?: unknown + failure?: { message: string } + }>['then'] +} + +async function mapWithConcurrency( + values: T[], + limit: number, + mapper: (value: T) => Promise, +): Promise { + const results = new Array(values.length) + let next = 0 + + async function worker(): Promise { + while (true) { + const index = next + next += 1 + if (index >= values.length) return + results[index] = await mapper(values[index]) + } + } + + await Promise.all( + Array.from({ length: Math.min(limit, values.length) }, () => worker()), + ) + return results +} + +/** + * Build v3-aware query operators (`eq`, `gte`, `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 `encrypt` — 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, + } + 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')[], + 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 + const MATCH_INDEXES = ['match'] as const + + function applyOperationOptions( + op: ChainableOperation, + opts?: EncryptionOperatorCallOpts, + ): ChainableOperation { + 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 }, + ) + } + + async function encryptOperand( + ctx: ColumnContext, + value: unknown, + operator: string, + opts?: EncryptionOperatorCallOpts, + ): Promise { + requireNonNullOperand(ctx, value, operator) + + const result = await applyOperationOptions( + client.encrypt(value as never, { + table: ctx.table, + column: ctx.builder, + }) as unknown as ChainableOperation, + opts, + ) + if (result.failure) { + throw operandFailure(ctx, operator, result.failure.message) + } + return sql`${JSON.stringify(result.data)}` + } + + /** + * Encrypt a whole operand list. Prefers the client's `bulkEncrypt` — one FFI + * crossing for the entire list, rather than one per value — and falls back to + * bounded-concurrency single encryption for clients that don't expose it. + * + * `bulkEncrypt` 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`). + */ + async function encryptOperands( + ctx: ColumnContext, + values: unknown[], + operator: string, + opts?: EncryptionOperatorCallOpts, + ): Promise { + for (const value of values) requireNonNullOperand(ctx, value, operator) + + const bulkEncrypt = client.bulkEncrypt?.bind(client) + if (!bulkEncrypt) { + return mapWithConcurrency(values, MAX_IN_ARRAY_CONCURRENCY, (value) => + encryptOperand(ctx, value, operator, opts), + ) + } + + const result = await applyOperationOptions( + bulkEncrypt(values.map((plaintext) => ({ plaintext })) as never, { + table: ctx.table, + column: ctx.builder, + }) as unknown as ChainableOperation, + opts, + ) + if (result.failure) { + throw operandFailure(ctx, operator, result.failure.message) + } + + const encrypted = result.data as Array<{ data: unknown }> | undefined + if (!Array.isArray(encrypted) || encrypted.length !== values.length) { + throw operandFailure( + ctx, + operator, + `bulk encryption returned ${Array.isArray(encrypted) ? encrypted.length : 0} terms for ${values.length} values.`, + ) + } + return encrypted.map((term) => sql`${JSON.stringify(term.data)}`) + } + + 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, 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, 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, opts), + encryptOperand(ctx, max, operator, 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 + } + + async function contains( + left: SQLWrapper, + right: unknown, + operator: string, + opts?: EncryptionOperatorCallOpts, + ): Promise { + const ctx = resolveContext(left, operator) + requireIndex(ctx, MATCH_INDEXES, operator, 'free-text search') + requireAnswerableNeedle(ctx, right, operator) + const enc = await encryptOperand(ctx, right, operator, opts) + return v3Dialect.contains(colSql(left), enc) + } + + 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 crossing where the client supports it. + requireIndex(ctx, EQUALITY_INDEXES, operator, 'equality') + const op: EqualityOp = negate ? 'ne' : 'eq' + const encrypted = await encryptOperands(ctx, values, operator, 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), + /** Free-text containment: emits `eql_v3.contains` over the encrypted match + * term. Encrypts `r`. Requires a `match` (free-text search) index. */ + contains: (l: SQLWrapper, r: unknown, opts?: EncryptionOperatorCallOpts) => + contains(l, r, 'contains', opts), + /** Membership: ORs one encrypted `eq` term per value. The whole list is + * encrypted in one `bulkEncrypt` crossing where the client supports it, + * otherwise concurrency-bounded. 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 `bulkEncrypt` crossing where the client supports it, + * otherwise concurrency-bounded. 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/src/eql/v3/drizzle/schema-extraction.ts b/packages/stack/src/eql/v3/drizzle/schema-extraction.ts new file mode 100644 index 000000000..623804ba9 --- /dev/null +++ b/packages/stack/src/eql/v3/drizzle/schema-extraction.ts @@ -0,0 +1,50 @@ +import type { PgTable } from 'drizzle-orm/pg-core' +import { + type AnyEncryptedV3Column, + type AnyV3Table, + encryptedTable, +} from '@/eql/v3' +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/src/eql/v3/drizzle/sql-dialect.ts b/packages/stack/src/eql/v3/drizzle/sql-dialect.ts new file mode 100644 index 000000000..50e2a4b05 --- /dev/null +++ b/packages/stack/src/eql/v3/drizzle/sql-dialect.ts @@ -0,0 +1,52 @@ +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}`) + +export const v3Dialect = { + equality(op: EqualityOp, left: SQL, enc: SQL): SQL { + return sql`${fn(op === 'eq' ? 'eq' : 'neq')}(${left}, ${enc}::jsonb)` + }, + + comparison(op: ComparisonOp, left: SQL, enc: SQL): SQL { + return sql`${fn(op)}(${left}, ${enc}::jsonb)` + }, + + /** + * 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}::jsonb) AND ${fn('lte')}(${left}, ${max}::jsonb))` + }, + + contains(left: SQL, enc: SQL): SQL { + return sql`${fn('contains')}(${left}, ${enc}::jsonb)` + }, + + 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/src/eql/v3/drizzle/types.ts b/packages/stack/src/eql/v3/drizzle/types.ts new file mode 100644 index 000000000..b52fe83f3 --- /dev/null +++ b/packages/stack/src/eql/v3/drizzle/types.ts @@ -0,0 +1,19 @@ +import { types as v3Types } from '@/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/src/eql/v3/index.ts b/packages/stack/src/eql/v3/index.ts index 3889f1f20..069dc7ad4 100644 --- a/packages/stack/src/eql/v3/index.ts +++ b/packages/stack/src/eql/v3/index.ts @@ -18,23 +18,19 @@ export type { } 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, @@ -43,6 +39,14 @@ export { 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..43a774c38 100644 --- a/packages/stack/src/eql/v3/types.ts +++ b/packages/stack/src/eql/v3/types.ts @@ -1,26 +1,30 @@ 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, @@ -29,6 +33,14 @@ import { EncryptedNumericEqColumn, EncryptedNumericOrdColumn, EncryptedNumericOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, EncryptedTextColumn, EncryptedTextEqColumn, EncryptedTextMatchColumn, @@ -39,18 +51,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 +59,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 +76,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 +104,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 +127,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 +184,9 @@ export const types = { DoubleOrdOre: (name: string) => new EncryptedDoubleOrdOreColumn(name, DOUBLE_ORD_ORE), DoubleOrd: (name: string) => new EncryptedDoubleOrdColumn(name, DOUBLE_ORD), -} as const + // `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..f2181c79b 100644 --- a/packages/stack/src/schema/match-defaults.ts +++ b/packages/stack/src/schema/match-defaults.ts @@ -52,3 +52,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 index 5f9c2070e..91ca28453 100644 --- a/packages/stack/src/supabase/helpers.ts +++ b/packages/stack/src/supabase/helpers.ts @@ -1,6 +1,12 @@ import type { EncryptedTable, EncryptedTableColumn } from '@/schema' import type { QueryTypeName } from '@/types' -import type { FilterOp, PendingOrCondition } from './types' +import type { + DbFilterString, + DbPendingOrCondition, + DbSelect, + FilterOp, + PendingOrCondition, +} from './types' /** * Get the names of all encrypted columns defined in a table schema. @@ -33,7 +39,8 @@ export function isEncryptedColumn( export function addJsonbCasts( columns: string, encryptedColumnNames: string[], -): string { +): DbSelect { + // The mapping below emits DB-space tokens; the brand is asserted once, here. return columns .split(',') .map((col) => { @@ -65,7 +72,25 @@ export function addJsonbCasts( return col }) - .join(',') + .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 } /** @@ -82,21 +107,14 @@ export function addJsonbCasts( * - 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 } { +): DbSelect { const dbNames = new Set(Object.values(propToDb)) - const keyToDb: Record = {} - const select = columns + return columns .split(',') .map((col) => { const trimmed = col.trim() @@ -113,32 +131,52 @@ export function addJsonbCastsV3( ) if (aliasMatch) { const [, alias, name] = aliasMatch - const db = propToDb[name] ?? (dbNames.has(name) ? name : undefined) + const db = + lookupDbName(propToDb, name) ?? (dbNames.has(name) ? name : undefined) if (db !== undefined) { - keyToDb[alias] = db return `${leadingWhitespace}${alias}:${db}::jsonb` } return col } - const db = propToDb[trimmed] + const db = lookupDbName(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(',') + .join(',') as DbSelect +} - return { select, keyToDb } +/** + * 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 } /** @@ -153,6 +191,7 @@ export function mapFilterOpToQueryType(op: FilterOp): QueryTypeName { return 'equality' case 'like': case 'ilike': + case 'contains': return 'freeTextSearch' case 'gt': case 'gte': @@ -168,23 +207,43 @@ export function mapFilterOpToQueryType(op: FilterOp): QueryTypeName { * 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%' }]` + * 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 = splitOrString(orString) + const parts = splitTopLevel(orString) for (const part of parts) { const trimmed = part.trim() if (!trimmed) continue - // Format: column.op.value + // Format: column.op.value — or column.not.op.value const firstDot = trimmed.indexOf('.') if (firstDot === -1) continue const column = trimmed.slice(0, firstDot) - const rest = trimmed.slice(firstDot + 1) + 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 @@ -193,45 +252,146 @@ export function parseOrString(orString: string): PendingOrCondition[] { const value = rest.slice(secondDot + 1) // Handle special value formats - const parsedValue = parseOrValue(value) + const parsedValue = parseOrValue(value, op) - conditions.push({ column, op, value: parsedValue }) + 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', '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' ? 'cs' : op +} + /** * Rebuild an `.or()` string from structured conditions. */ -export function rebuildOrString(conditions: PendingOrCondition[]): string { +export function rebuildOrString( + conditions: DbPendingOrCondition[], +): DbFilterString { + // Callers must hand DB-space `c.column` values (see `toDbSpace`). return conditions .map((c) => { - const value = formatOrValue(c.value) - return `${c.column}.${c.op}.${value}` + const op = orOperatorToken(c.op) + const value = formatOrValue(c.value, op) + const token = c.negate ? `not.${op}` : op + return `${c.column}.${token}.${value}` }) - .join(',') + .join(',') as DbFilterString } // --------------------------------------------------------------------------- // Internal helpers // --------------------------------------------------------------------------- -function splitOrString(input: string): string[] { +/** 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) { - if (char === '"' && depth === 0) { + // 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 (char === '(' && !inQuotes) { + } 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 (char === ')' && !inQuotes) { - depth-- + } else if ( + trackDepth && + (char === ')' || char === '}') && + !inQuotes && + depth > 0 + ) { + depth -= 1 current += char } else if (char === ',' && depth === 0 && !inQuotes) { parts.push(current) @@ -241,25 +401,64 @@ function splitOrString(input: string): string[] { } } - if (current) { - parts.push(current) - } + 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 } -function parseOrValue(value: string): unknown { - // Handle double-quoted values (PostgREST quoting for reserved characters) - if (value.startsWith('"') && value.endsWith('"')) { - return value.slice(1, -1) +/** + * 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) - if (value.startsWith('(') && value.endsWith(')')) { - return value - .slice(1, -1) - .split(',') - .map((v) => v.trim()) + // 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 @@ -273,14 +472,104 @@ function parseOrValue(value: string): unknown { } /** - * PostgREST reserved characters that require double-quoting in filter values. + * 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 = /[,().]/ +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 + } + } -function formatOrValue(value: unknown): string { if (Array.isArray(value)) { - return `(${value.join(',')})` + return `(${value.map((v) => formatOrValue(v)).join(',')})` } if (value === null) return 'null' if (value === true) return 'true' @@ -291,9 +580,45 @@ function formatOrValue(value: unknown): string { // 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}"` + 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/src/supabase/index.ts b/packages/stack/src/supabase/index.ts index cd9a6bb79..8e602fd28 100644 --- a/packages/stack/src/supabase/index.ts +++ b/packages/stack/src/supabase/index.ts @@ -1,14 +1,21 @@ -import type { AnyV3Table, InferPlaintext } from '@/eql/v3' +import { Encryption } from '@/encryption' import type { EncryptedTable, EncryptedTableColumn } from '@/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 { - EncryptedQueryBuilderV3, + EncryptedQueryBuilder, EncryptedSupabaseConfig, EncryptedSupabaseInstance, - EncryptedSupabaseV3Config, EncryptedSupabaseV3Instance, + EncryptedSupabaseV3Options, + SupabaseClientLike, + TypedEncryptedSupabaseV3Instance, + V3Schemas, } from './types' +import { verifyDeclaredSchemas } from './verify' /** * Create an encrypted Supabase wrapper that transparently handles encryption @@ -64,67 +71,215 @@ export function encryptedSupabase( } /** - * Create an encrypted Supabase wrapper for **EQL v3** schemas — tables - * authored with `@cipherstash/stack/eql/v3` whose columns are native - * `eql_v3.*` domains. + * Throw if `tableName` carries an EQL v3 column this SDK version cannot model. * - * 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). + * 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.) * - * @example - * ```typescript - * import { Encryption } from '@cipherstash/stack' - * import { encryptedTable, types } from '@cipherstash/stack/eql/v3' - * import { encryptedSupabaseV3 } from '@cipherstash/stack/supabase' + * 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. * - * const users = encryptedTable('users', { - * email: types.TextSearch('email'), // eql_v3.text_search - * amount: types.IntegerOrd('amount'), // eql_v3.integer_ord - * }) + * Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for + * introspection, so it cannot run in a Worker or the browser. * - * const client = await Encryption({ schemas: [users] }) - * const es = encryptedSupabaseV3({ encryptionClient: client, supabaseClient: supabase }) + * 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: * - * 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) + * ```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 function encryptedSupabaseV3( - config: EncryptedSupabaseV3Config, -): EncryptedSupabaseV3Instance { - const { encryptionClient, supabaseClient } = config +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 ?? {} + const { createClient } = await import('@supabase/supabase-js') + supabaseClient = createClient(url, key) as unknown as SupabaseClientLike + } else { + supabaseClient = clientOrUrl + options = + (keyOrOptions as EncryptedSupabaseV3Options) ?? {} + } - return { - from< - Table extends AnyV3Table, - Row extends Record = InferPlaintext
, - >(tableName: string, table: Table) { - return new EncryptedQueryBuilderV3Impl( + // 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, - ) as unknown as EncryptedQueryBuilderV3 + allColumns, + ) as unknown as EncryptedQueryBuilder> }, } + return instance as unknown as + | EncryptedSupabaseV3Instance + | TypedEncryptedSupabaseV3Instance } export type { EncryptedQueryBuilder, + EncryptedQueryBuilderCore, EncryptedQueryBuilderV3, + EncryptedQueryBuilderV3Untyped, EncryptedSupabaseConfig, EncryptedSupabaseError, EncryptedSupabaseInstance, EncryptedSupabaseResponse, - EncryptedSupabaseV3Config, EncryptedSupabaseV3Instance, + EncryptedSupabaseV3Options, PendingOrCondition, SupabaseClientLike, + TypedEncryptedSupabaseV3Instance, V3FilterableKeys, + V3FreeTextSearchableKeys, + V3Schemas, } from './types' diff --git a/packages/stack/src/supabase/introspect.ts b/packages/stack/src/supabase/introspect.ts new file mode 100644 index 000000000..4b58ea919 --- /dev/null +++ b/packages/stack/src/supabase/introspect.ts @@ -0,0 +1,214 @@ +import { DOMAIN_REGISTRY } from '@/eql/v3/domain-registry' + +/** 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/src/supabase/query-builder-v3.ts b/packages/stack/src/supabase/query-builder-v3.ts index 83b28921b..b76c8adee 100644 --- a/packages/stack/src/supabase/query-builder-v3.ts +++ b/packages/stack/src/supabase/query-builder-v3.ts @@ -1,12 +1,16 @@ import type { EncryptionClient } from '@/encryption' import type { AnyV3Table } from '@/eql/v3' -import { EncryptedV3Column } from '@/eql/v3/columns' +import { DATE_LIKE_CASTS, EncryptedV3Column } from '@/eql/v3/columns' import type { ColumnSchema, EncryptedTable, EncryptedTableColumn, } from '@/schema' -import type { BuildableQueryColumn, ScalarQueryTerm } from '@/types' +import type { + BuildableQueryColumn, + QueryTypeName, + ScalarQueryTerm, +} from '@/types' import { logger } from '@/utils/logger' import { addJsonbCastsV3 } from './helpers' import { @@ -14,22 +18,21 @@ import { EncryptionFailedError, } from './query-builder' import type { + DbName, + DbSelect, FilterOp, - PendingOrCondition, 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. - * - * 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 @@ -43,9 +46,41 @@ type V3ColumnLike = { } /** - * 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: + * 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 @@ -53,29 +88,45 @@ type V3ColumnLike = { * 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: … }` + * `public.*` 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.) + * - **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`). + * - **`contains`, not `like`/`ilike`** — the v3 domains define no LIKE operator. + * Free-text search is TOKEN CONTAINMENT: the bundle declares `@>` on each + * match domain (`CREATE OPERATOR @> … FUNCTION = eql_v3.contains`), whose body + * is `match_term(a) @> match_term(b)` — `smallint[]` containment of the two + * bloom filters. PostgREST reaches it as `cs`. + * + * Match is tokenized + downcased, so `%` is NOT a wildcard — it is tokenized + * like any other character, and a `like` pattern is a category error. v3 + * Drizzle omits `like`/`ilike` for this reason and exposes `contains`; so do + * we. The typed builder has no `like`; the runtime methods throw on an + * encrypted column and pass through on a plaintext one. + * + * KNOWN BROKEN for real substrings, and not fixable from this file. The + * operand is a storage payload, so its bloom carries the whole needle as an + * extra `include_original` token, which the haystack's bloom cannot contain + * unless the needle equals the stored value or is exactly `token_length` (3) + * characters. v3 Drizzle's `contains` has the same defect for the same + * reason. Tracked in EQL; do not paper over it here. * * Decrypted rows additionally get `Date` reconstruction from the * encrypt-config `cast_as`, mirroring the typed v3 client. @@ -86,24 +137,22 @@ export class EncryptedQueryBuilderV3Impl< 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 - /** - * 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, + allColumns: string[] | null = null, ) { super( tableName, @@ -113,13 +162,24 @@ export class EncryptedQueryBuilderV3Impl< table as unknown as EncryptedTable, encryptionClient, supabaseClient, + allColumns, ) this.v3Table = table this.propToDb = table.buildColumnKeyMap() this.columnSchemas = table.build().columns - this.v3Columns = {} + 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 @@ -142,27 +202,117 @@ export class EncryptedQueryBuilderV3Impl< return this.v3Columns as unknown as Record } - protected override filterColumnName(column: string): string { - return this.propToDb[column] ?? column + /** 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 + } + + /** + * Ordering by ANY encrypted v3 column is rejected — including the ORE-capable + * ones, which is the non-obvious half. + * + * 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 `ORDER BY col` does not reach `eql_v3`'s ORE comparisons at + * all: it resolves through jsonb's DEFAULT btree opclass, `jsonb_cmp`, and + * sorts by the envelope's byte structure — keys compare alphabetically, so the + * sort is effectively on the `bf` bloom array. No error, no warning, and a + * stable, plausible-looking, meaningless row order. + * + * Correct ordering is `ORDER BY eql_v3.ord_term(col)`, which PostgREST's + * `order=` parameter cannot express. The v3 Drizzle integration emits exactly + * that (`sql-dialect.ts` `orderBy`), and proves it against live Postgres. + * + * The `>=`/`<=` operators ARE declared on the ord domains, so `gte`/`lte` + * filters remain correct. Filtering and sorting resolve through different + * machinery; only sorting is broken. + * + * 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 + throw new Error( + `[supabase v3]: cannot order by encrypted column "${column.getName()}" (${column.getEqlType()}) — PostgREST cannot emit \`ORDER BY eql_v3.ord_term("${column.getName()}")\`, and a bare \`ORDER BY\` sorts the raw ciphertext envelope, not the plaintext. Order by a plaintext column, expose \`eql_v3.ord_term()\` as a generated column or view and order by that, or use the EQL v3 Drizzle integration.`, + ) + } } - protected override buildSelectString(): string | null { + /** + * 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 - const { select, keyToDb } = addJsonbCastsV3( - this.selectColumns, - this.propToDb, + 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, ) - 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 = {} + const out: Record = Object.create(null) for (const [key, value] of Object.entries(model)) { - out[this.propToDb[key] ?? key] = value + out[this.dbNameFor(key)] = value } return out } @@ -174,57 +324,136 @@ export class EncryptedQueryBuilderV3Impl< } /** - * Encrypt every filter operand as a full storage envelope (see the class - * doc for why `encryptQuery` terms cannot be used), serialized to jsonb + * 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?: unknown): never { + logger.error( + `Supabase: failed to encrypt query terms for table "${this.tableName}"`, + ) + throw new EncryptionFailedError( + `Failed to encrypt query terms: ${message}`, + cause, + ) + } + + /** + * Encrypt every filter operand as a full storage envelope, 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. + * 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 { - 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`, - ) - } + 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) + }) - if ( - queryType !== 'equality' && - queryType !== 'orderAndRange' && - queryType !== 'freeTextSearch' - ) { - throw new Error( - `[supabase v3]: query type "${queryType}" is not supported on scalar eql_v3 columns`, - ) - } + const bulkEncrypt = this.encryptionClient.bulkEncrypt?.bind( + this.encryptionClient, + ) + const results = new Array(terms.length) - 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`, - ) - } + 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) - const baseOp = this.encryptionClient.encrypt(term.value, { + // `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. + const encrypted = result.data as Array<{ data: unknown }> | undefined + if (!Array.isArray(encrypted) || encrypted.length !== values.length) { + this.encryptionFailure( + `bulk encryption returned ${Array.isArray(encrypted) ? encrypted.length : 0} terms for ${values.length} values on column "${column.getName()}".`, + ) + } + return encrypted.map((term) => 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, }) @@ -235,89 +464,88 @@ export class EncryptedQueryBuilderV3Impl< 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, - ) + this.encryptionFailure(result.failure.message, result.failure) } - - return JSON.stringify(result.data) + return 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. + * `like`/`ilike` do not exist on the v3 surface (see the class doc). The + * typed builder omits them, but an untyped JS caller can still reach them — + * refuse loudly rather than emit a `~~` the domain has no operator for. + * + * A plaintext column is a genuine PostgREST text column, so `like` there is + * exactly what the caller means; let it through. */ - private encryptedFilterOp(op: string, wasEncrypted: boolean): string { - return wasEncrypted && (op === 'like' || op === 'ilike') ? 'cs' : op + private assertNotEncryptedPattern(column: string, op: string): void { + if (!this.v3Columns[column]) return + throw new Error( + `[supabase v3]: "${op}" is not supported on encrypted column "${column}" — EQL v3 free-text search is token containment, not SQL wildcard matching ("%" is tokenized like any other character). Use contains().`, + ) + } + + override like(column: string, pattern: string): this { + this.assertNotEncryptedPattern(column, 'like') + return super.like(column, pattern) } - /** Encrypted pattern filters go through the bloom-filter `@>` (`cs`). */ - protected override applyPatternFilter( + override ilike(column: string, pattern: string): this { + this.assertNotEncryptedPattern(column, 'ilike') + return super.ilike(column, pattern) + } + + /** + * Encrypted `contains` 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` 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. + */ + protected override applyContainsFilter( q: SupabaseQueryBuilder, - column: string, - op: 'like' | 'ilike', + column: DbName, value: unknown, wasEncrypted: boolean, ): SupabaseQueryBuilder { - const wireOp = this.encryptedFilterOp(op, wasEncrypted) - if (wireOp !== op) { - return q.filter(column, wireOp, value) + if (wasEncrypted) { + return q.filter(column, 'cs', value) } - return super.applyPatternFilter(q, column, op, value, wasEncrypted) - } - - protected override notFilterOperator( - op: FilterOp, - wasEncrypted: boolean, - ): string { - return this.encryptedFilterOp(op, wasEncrypted) + return super.applyContainsFilter(q, column, value, 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, - })) + /** + * `.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. + */ + protected override queryTypeForOrOp(op: FilterOp): QueryTypeName { + if (op === 'contains') return 'freeTextSearch' + return this.queryTypeForRawOp(op) } - /** Rebuild `Date` values from the encrypt-config `cast_as`, mirroring the - * typed v3 client's decrypt-model path. */ + /** 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 { - // 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`. + for (const [property, dbName] of Object.entries(this.propToDb)) { 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) + if (!DATE_LIKE_CAST_SET.has(castAs as string)) continue + // Rows are keyed by property name when selected via the aliasing cast + // helper, but a caller selecting by raw DB name gets DB-name keys. + for (const key of property === dbName ? [property] : [property, dbName]) { + const value = out[key] + if (value == null || value instanceof Date) continue + if (typeof value === 'string' || typeof value === 'number') { + out[key] = new Date(value) + } } } return out diff --git a/packages/stack/src/supabase/query-builder.ts b/packages/stack/src/supabase/query-builder.ts index 5e520b0b4..7f9d84af5 100644 --- a/packages/stack/src/supabase/query-builder.ts +++ b/packages/stack/src/supabase/query-builder.ts @@ -8,17 +8,34 @@ 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 type { + BuildableQueryColumn, + QueryTypeName, + ScalarQueryTerm, +} from '@/types' import { logger } from '@/utils/logger' 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 +68,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 +97,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 +112,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 +234,11 @@ export class EncryptedQueryBuilderImpl< return this } + contains(column: string, value: unknown): this { + this.filters.push({ op: 'contains', column, value }) + return this + } + is(column: string, value: null | boolean): this { this.filters.push({ op: 'is', column, value }) return this @@ -350,17 +393,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) @@ -468,7 +515,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 +524,182 @@ 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 + if (!isEncryptableTerm(rf.operator, rf.value)) continue const column = tableColumns[rf.column] if (!column) continue - terms.push({ - value: rf.value as JsPlaintext, + 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) { @@ -655,6 +742,111 @@ 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) } + } + + private transformToDbSpace(t: TransformOp): DbTransformOp { + switch (t.kind) { + case 'order': + return { ...t, column: this.filterColumnName(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 +856,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 +887,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 +934,7 @@ export class EncryptedQueryBuilderImpl< protected applyFilters( query: SupabaseQueryBuilder, encryptedFilters: EncryptedFilterState, + dbSpace: DbQuerySpace, ): SupabaseQueryBuilder { let q = query @@ -747,6 +943,7 @@ 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 orStringConditionMap = new Map() // "orIndex:condIndex" -> value const orStructuredConditionMap = new Map() @@ -770,29 +967,29 @@ 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) 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 +1002,7 @@ export class EncryptedQueryBuilderImpl< }) } - const column = this.filterColumnName(f.column) + const column = f.column const wasEncrypted = filterValueMap.has(i) switch (f.op) { @@ -831,23 +1028,34 @@ export class EncryptedQueryBuilderImpl< case 'ilike': q = this.applyPatternFilter(q, column, f.op, value, wasEncrypted) break + case 'contains': + 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 +1064,89 @@ 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') { + 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] 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 +1162,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 filterColumnName(column: string): string { - return column + 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 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 +1244,7 @@ export class EncryptedQueryBuilderImpl< */ protected applyPatternFilter( q: SupabaseQueryBuilder, - column: string, + column: DbName, op: 'like' | 'ilike', value: unknown, _wasEncrypted: boolean, @@ -959,23 +1255,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 +1464,67 @@ export class EncryptedQueryBuilderImpl< type TermMapping = | { source: 'filter'; filterIndex: number; inIndex?: number } | { source: 'match'; matchIndex: number; column: string } - | { source: 'not'; notIndex: number } + | { source: 'not'; notIndex: number; inIndex?: number } | { source: 'raw'; rawIndex: number } - | { source: 'or-string'; orIndex: number; conditionIndex: number } - | { source: 'or-structured'; orIndex: number; conditionIndex: number } + | { + source: 'or-string' + orIndex: number + conditionIndex: number + inIndex?: number + } + | { + source: 'or-structured' + orIndex: number + conditionIndex: number + inIndex?: number + } type EncryptedFilterState = { encryptedValues: unknown[] 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: { diff --git a/packages/stack/src/supabase/schema-builder.ts b/packages/stack/src/supabase/schema-builder.ts new file mode 100644 index 000000000..ba5f22f9f --- /dev/null +++ b/packages/stack/src/supabase/schema-builder.ts @@ -0,0 +1,94 @@ +import { type AnyV3Table, EncryptedTable } from '@/eql/v3' +import type { AnyEncryptedV3Column } from '@/eql/v3/columns' +import { factoryForDomain } from '@/eql/v3/domain-registry' +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/src/supabase/types.ts b/packages/stack/src/supabase/types.ts index c24792d9f..2c0761161 100644 --- a/packages/stack/src/supabase/types.ts +++ b/packages/stack/src/supabase/types.ts @@ -4,6 +4,8 @@ import type { AnyV3Table, InferPlaintext, QueryTypesForColumn } from '@/eql/v3' import type { EncryptionError } from '@/errors' import type { LockContext } from '@/identity' import type { EncryptedTable, EncryptedTableColumn } from '@/schema' +import type { ClientConfig } from '@/types' +import type { V3Schemas } from './schema-builder' // --------------------------------------------------------------------------- // Config & instance @@ -25,9 +27,37 @@ export interface EncryptedSupabaseInstance { // EQL v3 config & instance // --------------------------------------------------------------------------- -export type EncryptedSupabaseV3Config = { - encryptionClient: EncryptionClient - supabaseClient: SupabaseClientLike +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. `include_original: true` is therefore always in force, so a + * substring `contains` matches nothing on either. See the `contains` note on + * `EncryptedQueryBuilderV3Impl`. + */ + schemas?: S } /** @@ -65,28 +95,196 @@ export type V3FilterableKeys< > = Exclude, NonQueryableV3Keys
> /** - * The v3 builder type: the shared {@link EncryptedQueryBuilder} surface with - * filter methods narrowed to {@link V3FilterableKeys}. + * 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
> + +/** + * 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 + +/** + * Row keys a v3 builder accepts in `order()`: every row key that is NOT an + * encrypted v3 column. `ORDER BY` on an EQL v3 domain sorts the raw ciphertext + * envelope — the bundle declares no btree operator class on any domain, so the + * sort resolves through jsonb's default `jsonb_cmp`. Correct ordering needs + * `eql_v3.ord_term(col)`, which PostgREST cannot emit. + */ +export type V3OrderableKeys< + 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 token + * containment over a bloom filter (`@>`), 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 `contains`. */ -export type EncryptedQueryBuilderV3< +export interface EncryptedQueryBuilderV3< Table extends AnyV3Table, Row extends Record, -> = EncryptedQueryBuilder & StringKeyOf> +> extends EncryptedQueryBuilderCore< + Row, + V3FilterableKeys & StringKeyOf, + EncryptedQueryBuilderV3, + V3OrderableKeys & StringKeyOf, + // `is(col, true)` is legal only on a plaintext column. That is exactly the + // orderable set today — every encrypted column is excluded from both — but + // the two are threaded separately so they can diverge. + V3OrderableKeys & StringKeyOf + > { + contains & StringKeyOf>( + column: K, + value: V3ContainsValue, + ): 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 `contains` accepts the full native operand union + * (which subsumes the encrypted column's `string`); the runtime resolves the + * column and picks the encoding. + */ +export interface EncryptedQueryBuilderV3Untyped< + Row extends Record, +> extends EncryptedQueryBuilderCore< + Row, + StringKeyOf, + EncryptedQueryBuilderV3Untyped + > { + contains>( + column: K, + value: NativeContainsValue, + ): EncryptedQueryBuilderV3Untyped +} +/** Untyped instance (no `schemas`): rows default to `Record` + * and `from` accepts any table name. */ 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 + 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 } // --------------------------------------------------------------------------- @@ -118,6 +316,9 @@ export type FilterOp = | 'neq' | 'like' | 'ilike' + /** Token containment. v3-only on encrypted columns; on a plaintext column it + * is PostgREST's native jsonb/array `cs`. */ + | 'contains' | 'in' | 'gt' | 'gte' @@ -138,6 +339,9 @@ export type PendingOrFilter = 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 } @@ -215,46 +419,139 @@ export type MutationOp = 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?: string, + columns?: DbSelect, 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 + insert(values: unknown, options?: DbMutationOptions): SupabaseQueryBuilder + update(values: unknown, options?: DbMutationOptions): SupabaseQueryBuilder + upsert(values: unknown, options?: DbMutationOptions): 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 + 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: string, + filters: DbFilterString, options?: { referencedTable?: string; foreignTable?: string }, ): SupabaseQueryBuilder match(query: Record): SupabaseQueryBuilder - order(column: string, options?: Record): SupabaseQueryBuilder + order(column: DbName, options?: Record): SupabaseQueryBuilder limit(count: number, options?: Record): SupabaseQueryBuilder range( from: number, @@ -298,14 +595,38 @@ export type { /** Helper to extract string keys from T */ type StringKeyOf = Extract -export interface EncryptedQueryBuilder< - T extends Record = Record, - FK extends StringKeyOf = StringKeyOf, +/** + * 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, + columns?: string, options?: { head?: boolean; count?: 'exact' | 'planned' | 'estimated' }, - ): EncryptedQueryBuilder + ): Self insert( data: Partial | Partial[], options?: { @@ -313,11 +634,11 @@ export interface EncryptedQueryBuilder< defaultToNull?: boolean onConflict?: string }, - ): EncryptedQueryBuilder + ): Self update( data: Partial, options?: { count?: 'exact' | 'planned' | 'estimated' }, - ): EncryptedQueryBuilder + ): Self upsert( data: Partial | Partial[], options?: { @@ -326,43 +647,51 @@ export interface EncryptedQueryBuilder< 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 + ): 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 }, - ): EncryptedQueryBuilder + ): Self or( conditions: PendingOrCondition[], options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder - match(query: Partial>): EncryptedQueryBuilder - order>( + ): 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 @@ -370,22 +699,32 @@ export interface EncryptedQueryBuilder< referencedTable?: string foreignTable?: string }, - ): EncryptedQueryBuilder + ): Self limit( count: number, options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder + ): Self range( from: number, to: number, options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder - single(): EncryptedQueryBuilder - maybeSingle(): EncryptedQueryBuilder - csv(): EncryptedQueryBuilder - abortSignal(signal: AbortSignal): EncryptedQueryBuilder - throwOnError(): EncryptedQueryBuilder + ): 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): EncryptedQueryBuilder - audit(config: AuditConfig): 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/src/supabase/verify.ts b/packages/stack/src/supabase/verify.ts new file mode 100644 index 000000000..b20226fd8 --- /dev/null +++ b/packages/stack/src/supabase/verify.ts @@ -0,0 +1,64 @@ +import { stripDomainSchema } from '@/eql/v3/domain-registry' +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/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..48db3a32f 100644 --- a/packages/stack/src/wasm-inline.ts +++ b/packages/stack/src/wasm-inline.ts @@ -125,12 +125,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 diff --git a/packages/stack/tsup.config.ts b/packages/stack/tsup.config.ts index 100065f0c..64a6152da 100644 --- a/packages/stack/tsup.config.ts +++ b/packages/stack/tsup.config.ts @@ -15,6 +15,7 @@ export default defineConfig([ 'src/identity/index.ts', 'src/schema/index.ts', 'src/eql/v3/index.ts', + 'src/eql/v3/drizzle/index.ts', 'src/drizzle/index.ts', 'src/dynamodb/index.ts', 'src/supabase/index.ts', @@ -28,7 +29,7 @@ export default defineConfig([ clean: false, target: 'es2022', tsconfig: './tsconfig.json', - external: ['drizzle-orm', '@supabase/supabase-js'], + external: ['drizzle-orm', '@supabase/supabase-js', 'pg'], // 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 +51,7 @@ export default defineConfig([ clean: false, target: 'es2022', tsconfig: './tsconfig.json', - external: ['drizzle-orm', '@supabase/supabase-js'], + external: ['drizzle-orm', '@supabase/supabase-js', 'pg'], noExternal: ['evlog', 'uuid', 'zod', '@byteslice/result'], }, ]) diff --git a/packages/stack/vitest.config.ts b/packages/stack/vitest.config.ts index c4b1da040..2f8acabec 100644 --- a/packages/stack/vitest.config.ts +++ b/packages/stack/vitest.config.ts @@ -21,11 +21,32 @@ export default defineConfig({ }, }, test: { + // Live suites make real ZeroKMS / CTS network round-trips. The vast + // majority of these tests already pass an explicit `, 30000)` per-test + // timeout (300+ call sites); a handful were written without one and so + // fell back to Vitest's 5000ms default. Under the default forks pool with + // file parallelism, many live suites hit ZeroKMS concurrently and those + // 5000ms-default tests intermittently time out (they pass in isolation). + // Align the global default with the dominant explicit value so the intent + // is uniform. 30s is comfortably above real network latency but still low + // enough to surface a genuine hang. + testTimeout: 30000, + hookTimeout: 30000, typecheck: { // Scoped tsconfig keeps the 124 pre-existing wasm-inline typecheck errors // out of scope (tracked as a follow-up). Run via the `test:types` script // 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/pnpm-lock.yaml b/pnpm-lock.yaml index 97b2c71c2..2613ace6b 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -261,6 +261,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 @@ -581,8 +584,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 +596,21 @@ 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 + '@supabase/postgrest-js': + specifier: 2.105.4 + version: 2.105.4 '@supabase/supabase-js': specifier: ^2.105.4 version: 2.105.4 + '@types/pg': + specifier: ^8.20.0 + version: 8.20.0 '@types/uuid': specifier: ^11.0.0 version: 11.0.0 @@ -607,16 +619,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 @@ -972,13 +990,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 +1008,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 +1018,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 +1028,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 +1038,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 +1048,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==} @@ -4516,40 +4537,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 +4586,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: @@ -5697,7 +5720,7 @@ snapshots: '@types/pg@8.20.0': dependencies: '@types/node': 22.19.19 - pg-protocol: 1.13.0 + pg-protocol: 1.15.0 pg-types: 2.2.0 '@types/semver@7.5.8': {} @@ -5996,14 +6019,6 @@ snapshots: pg: 8.20.0 postgres: 3.4.9 - drizzle-orm@0.45.2(@types/pg@8.20.0)(gel@2.2.0)(mysql2@3.16.0)(pg@8.21.0)(postgres@3.4.9): - optionalDependencies: - '@types/pg': 8.20.0 - gel: 2.2.0 - mysql2: 3.16.0 - pg: 8.21.0 - postgres: 3.4.9 - dunder-proto@1.0.1: dependencies: call-bind-apply-helpers: 1.0.2 @@ -6731,7 +6746,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 +6778,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: 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..206bf8bef 100644 --- a/skills/stash-drizzle/SKILL.md +++ b/skills/stash-drizzle/SKILL.md @@ -1,6 +1,6 @@ --- 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/eql/v3/drizzle), 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 @@ -15,6 +15,7 @@ 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 @@ -710,3 +711,79 @@ class EncryptionConfigError extends Error { ``` Encryption client operations return `Result` objects with `data` or `failure`. + +## EQL v3 Integration (`@cipherstash/stack/eql/v3/drizzle`) + +Everything above covers the v2 integration (`@cipherstash/stack/drizzle`). The **EQL v3** typed schema has its own Drizzle integration on the `@cipherstash/stack/eql/v3/drizzle` 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/eql/v3/drizzle" + +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.contains(users.email, "alice"), // free-text containment + 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`) | +| `contains` | free-text (`TextMatch`, `TextSearch`) | +| `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 containment, not SQL pattern matching; `contains(col, needle)` is the free-text operator. Don't pass `%` wildcards. +- **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 `bulkEncrypt` crossing when the client exposes one. +- `contains` rejects a needle shorter than the match tokenizer's token length (it 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/eql/v3/drizzle` 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..a2aee1353 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 @@ -124,6 +125,9 @@ The SDK never logs plaintext data. | `@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/eql/v3/drizzle` | Drizzle ORM integration for EQL v3 schemas (see the `stash-drizzle` skill) | ## Schema Definition @@ -584,6 +588,165 @@ 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 | + +**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` | + +Examples: `types.Text("notes")` (storage only), `types.TextEq("username")`, `types.BigintOrd("balance")`, `types.TimestampOrdOre("created_at")`, `types.Boolean("active")`. + +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", +}) +``` + +### 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/eql/v3/drizzle` 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..44034ae92 100644 --- a/skills/stash-supabase/SKILL.md +++ b/skills/stash-supabase/SKILL.md @@ -401,49 +401,71 @@ type EncryptedSupabaseError = { - `EncryptedQueryBuilder` - `PendingOrCondition` - `SupabaseClientLike` -- `EncryptedSupabaseV3Config`, `EncryptedSupabaseV3Instance`, `EncryptedQueryBuilderV3` (EQL v3) +- `EncryptedSupabaseV3Options`, `EncryptedSupabaseV3Instance`, `TypedEncryptedSupabaseV3Instance`, `EncryptedQueryBuilderV3`, `EncryptedQueryBuilderV3Untyped`, `V3Schemas` (EQL v3) -## EQL v3 (native `eql_v3.*` domains) +## EQL v3 (native `public.eql_v3_*` domains) -`encryptedSupabaseV3` is the EQL v3 counterpart of `encryptedSupabase` for -schemas authored with `@cipherstash/stack/eql/v3`. The public surface and call -shape are **identical to v2** — same filter methods, `withLockContext`, -`audit` — only the schema type and the wire encoding differ. Columns are -stored in their native `eql_v3.*` domain (a `DOMAIN … AS jsonb` with a CHECK) -instead of the v2 composite `eql_v2_encrypted`. +`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`. + +The query surface matches v2 — same filter methods, `withLockContext`, +`audit` — with one deliberate fork: free-text search is `contains()`, and +`like`/`ilike` are rejected on encrypted columns (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" 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, `contains()` 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 +475,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 +495,67 @@ 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.) +- **Free-text search is `contains()`, not `like`/`ilike`.** The v3 domains + define no LIKE operator — free-text search is bloom-filter token + containment (PostgREST `cs` / SQL `@>`), where `%` is tokenized like any + other character, so a `like` pattern is a category error. Calling `like` or + `ilike` on an encrypted column throws an error pointing at `contains()`; + on plaintext columns both pass through unchanged. +- **`contains()` matches exact values, not general substrings.** The match + index always uses its default configuration, in which the query's bloom + filter carries the whole search term as an extra token — so `contains()` + matches when the term equals the stored value (or is exactly one token, + 3 characters, long); longer substrings do not match. This is a known + limitation tracked upstream in EQL. +- **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.